Removing DOS 8x3 support
diff --git a/Lib/dos-8x3/basehttp.py b/Lib/dos-8x3/basehttp.py
deleted file mode 100755
index 49f8984..0000000
--- a/Lib/dos-8x3/basehttp.py
+++ /dev/null
@@ -1,482 +0,0 @@
-"""HTTP server base class.
-
-Note: the class in this module doesn't implement any HTTP request; see
-SimpleHTTPServer for simple implementations of GET, HEAD and POST
-(including CGI scripts).
-
-Contents:
-
-- BaseHTTPRequestHandler: HTTP request handler base class
-- test: test function
-
-XXX To do:
-
-- send server version
-- log requests even later (to capture byte count)
-- log user-agent header and other interesting goodies
-- send error log to separate file
-- are request names really case sensitive?
-
-"""
-
-
-# See also:
-#
-# HTTP Working Group T. Berners-Lee
-# INTERNET-DRAFT R. T. Fielding
-# <draft-ietf-http-v10-spec-00.txt> H. Frystyk Nielsen
-# Expires September 8, 1995 March 8, 1995
-#
-# URL: http://www.ics.uci.edu/pub/ietf/http/draft-ietf-http-v10-spec-00.txt
-
-
-# Log files
-# ---------
-#
-# Here's a quote from the NCSA httpd docs about log file format.
-#
-# | The logfile format is as follows. Each line consists of:
-# |
-# | host rfc931 authuser [DD/Mon/YYYY:hh:mm:ss] "request" ddd bbbb
-# |
-# | host: Either the DNS name or the IP number of the remote client
-# | rfc931: Any information returned by identd for this person,
-# | - otherwise.
-# | authuser: If user sent a userid for authentication, the user name,
-# | - otherwise.
-# | DD: Day
-# | Mon: Month (calendar name)
-# | YYYY: Year
-# | hh: hour (24-hour format, the machine's timezone)
-# | mm: minutes
-# | ss: seconds
-# | request: The first line of the HTTP request as sent by the client.
-# | ddd: the status code returned by the server, - if not available.
-# | bbbb: the total number of bytes sent,
-# | *not including the HTTP/1.0 header*, - if not available
-# |
-# | You can determine the name of the file accessed through request.
-#
-# (Actually, the latter is only true if you know the server configuration
-# at the time the request was made!)
-
-
-__version__ = "0.2"
-
-
-import sys
-import time
-import socket # For gethostbyaddr()
-import string
-import mimetools
-import SocketServer
-
-# Default error message
-DEFAULT_ERROR_MESSAGE = """\
-<head>
-<title>Error response</title>
-</head>
-<body>
-<h1>Error response</h1>
-<p>Error code %(code)d.
-<p>Message: %(message)s.
-<p>Error code explanation: %(code)s = %(explain)s.
-</body>
-"""
-
-
-class HTTPServer(SocketServer.TCPServer):
-
- allow_reuse_address = 1 # Seems to make sense in testing environment
-
- def server_bind(self):
- """Override server_bind to store the server name."""
- SocketServer.TCPServer.server_bind(self)
- host, port = self.socket.getsockname()
- self.server_name = socket.getfqdn(host)
- self.server_port = port
-
-
-class BaseHTTPRequestHandler(SocketServer.StreamRequestHandler):
-
- """HTTP request handler base class.
-
- The following explanation of HTTP serves to guide you through the
- code as well as to expose any misunderstandings I may have about
- HTTP (so you don't need to read the code to figure out I'm wrong
- :-).
-
- HTTP (HyperText Transfer Protocol) is an extensible protocol on
- top of a reliable stream transport (e.g. TCP/IP). The protocol
- recognizes three parts to a request:
-
- 1. One line identifying the request type and path
- 2. An optional set of RFC-822-style headers
- 3. An optional data part
-
- The headers and data are separated by a blank line.
-
- The first line of the request has the form
-
- <command> <path> <version>
-
- where <command> is a (case-sensitive) keyword such as GET or POST,
- <path> is a string containing path information for the request,
- and <version> should be the string "HTTP/1.0". <path> is encoded
- using the URL encoding scheme (using %xx to signify the ASCII
- character with hex code xx).
-
- The protocol is vague about whether lines are separated by LF
- characters or by CRLF pairs -- for compatibility with the widest
- range of clients, both should be accepted. Similarly, whitespace
- in the request line should be treated sensibly (allowing multiple
- spaces between components and allowing trailing whitespace).
-
- Similarly, for output, lines ought to be separated by CRLF pairs
- but most clients grok LF characters just fine.
-
- If the first line of the request has the form
-
- <command> <path>
-
- (i.e. <version> is left out) then this is assumed to be an HTTP
- 0.9 request; this form has no optional headers and data part and
- the reply consists of just the data.
-
- The reply form of the HTTP 1.0 protocol again has three parts:
-
- 1. One line giving the response code
- 2. An optional set of RFC-822-style headers
- 3. The data
-
- Again, the headers and data are separated by a blank line.
-
- The response code line has the form
-
- <version> <responsecode> <responsestring>
-
- where <version> is the protocol version (always "HTTP/1.0"),
- <responsecode> is a 3-digit response code indicating success or
- failure of the request, and <responsestring> is an optional
- human-readable string explaining what the response code means.
-
- This server parses the request and the headers, and then calls a
- function specific to the request type (<command>). Specifically,
- a request SPAM will be handled by a method do_SPAM(). If no
- such method exists the server sends an error response to the
- client. If it exists, it is called with no arguments:
-
- do_SPAM()
-
- Note that the request name is case sensitive (i.e. SPAM and spam
- are different requests).
-
- The various request details are stored in instance variables:
-
- - client_address is the client IP address in the form (host,
- port);
-
- - command, path and version are the broken-down request line;
-
- - headers is an instance of mimetools.Message (or a derived
- class) containing the header information;
-
- - rfile is a file object open for reading positioned at the
- start of the optional input data part;
-
- - wfile is a file object open for writing.
-
- IT IS IMPORTANT TO ADHERE TO THE PROTOCOL FOR WRITING!
-
- The first thing to be written must be the response line. Then
- follow 0 or more header lines, then a blank line, and then the
- actual data (if any). The meaning of the header lines depends on
- the command executed by the server; in most cases, when data is
- returned, there should be at least one header line of the form
-
- Content-type: <type>/<subtype>
-
- where <type> and <subtype> should be registered MIME types,
- e.g. "text/html" or "text/plain".
-
- """
-
- # The Python system version, truncated to its first component.
- sys_version = "Python/" + string.split(sys.version)[0]
-
- # The server software version. You may want to override this.
- # The format is multiple whitespace-separated strings,
- # where each string is of the form name[/version].
- server_version = "BaseHTTP/" + __version__
-
- def parse_request(self):
- """Parse a request (internal).
-
- The request should be stored in self.raw_request; the results
- are in self.command, self.path, self.request_version and
- self.headers.
-
- Return value is 1 for success, 0 for failure; on failure, an
- error is sent back.
-
- """
- 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 0
- elif len(words) == 2:
- [command, path] = words
- if command != 'GET':
- self.send_error(400,
- "Bad HTTP/0.9 request type (%s)" % `command`)
- return 0
- else:
- self.send_error(400, "Bad request syntax (%s)" % `requestline`)
- return 0
- self.command, self.path, self.request_version = command, path, version
- self.headers = self.MessageClass(self.rfile, 0)
- return 1
-
- 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()
- if not self.parse_request(): # An error code has been sent, just exit
- return
- mname = 'do_' + self.command
- if not hasattr(self, mname):
- self.send_error(501, "Unsupported method (%s)" % `self.command`)
- return
- method = getattr(self, mname)
- method()
-
- def send_error(self, code, message=None):
- """Send and log an error reply.
-
- Arguments are the error code, and a detailed message.
- The detailed message defaults to the short entry matching the
- response code.
-
- This sends an error response (so it must be called before any
- output has been generated), logs the error, and finally sends
- a piece of HTML explaining the error to the user.
-
- """
-
- try:
- short, long = self.responses[code]
- except KeyError:
- short, long = '???', '???'
- if not message:
- message = short
- explain = long
- self.log_error("code %d, message %s", code, message)
- self.send_response(code, message)
- self.end_headers()
- self.wfile.write(self.error_message_format %
- {'code': code,
- 'message': message,
- 'explain': explain})
-
- error_message_format = DEFAULT_ERROR_MESSAGE
-
- def send_response(self, code, message=None):
- """Send the response header and log the response code.
-
- Also send two standard headers with the server software
- version and the current date.
-
- """
- self.log_request(code)
- if message is None:
- if self.responses.has_key(code):
- message = self.responses[code][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))
-
- def end_headers(self):
- """Send the blank line ending the MIME headers."""
- if self.request_version != 'HTTP/0.9':
- self.wfile.write("\r\n")
-
- def log_request(self, code='-', size='-'):
- """Log an accepted request.
-
- This is called by send_reponse().
-
- """
-
- self.log_message('"%s" %s %s',
- self.requestline, str(code), str(size))
-
- def log_error(self, *args):
- """Log an error.
-
- This is called when a request cannot be fulfilled. By
- default it passes the message on to log_message().
-
- Arguments are the same as for log_message().
-
- XXX This should go to the separate error log.
-
- """
-
- apply(self.log_message, args)
-
- def log_message(self, format, *args):
- """Log an arbitrary message.
-
- This is used by all other logging functions. Override
- it if you have specific logging wishes.
-
- The first argument, FORMAT, is a format string for the
- message to be logged. If the format string contains
- any % escapes requiring parameters, they should be
- specified as subsequent arguments (it's just like
- printf!).
-
- The client host and current date/time are prefixed to
- every message.
-
- """
-
- sys.stderr.write("%s - - [%s] %s\n" %
- (self.address_string(),
- self.log_date_time_string(),
- format%args))
-
- def version_string(self):
- """Return the server software version string."""
- return self.server_version + ' ' + self.sys_version
-
- def date_time_string(self):
- """Return the current date and time formatted for a message header."""
- now = time.time()
- year, month, day, hh, mm, ss, wd, y, z = time.gmtime(now)
- s = "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (
- self.weekdayname[wd],
- day, self.monthname[month], year,
- hh, mm, ss)
- return s
-
- def log_date_time_string(self):
- """Return the current time formatted for logging."""
- now = time.time()
- year, month, day, hh, mm, ss, x, y, z = time.localtime(now)
- s = "%02d/%3s/%04d %02d:%02d:%02d" % (
- day, self.monthname[month], year, hh, mm, ss)
- return s
-
- weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
-
- monthname = [None,
- 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
- 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
-
- def address_string(self):
- """Return the client address formatted for logging.
-
- This version looks up the full hostname using gethostbyaddr(),
- and tries to find a name that contains at least one dot.
-
- """
-
- host, port = self.client_address
- return socket.getfqdn(host)
-
- # Essentially static class variables
-
- # The version of the HTTP protocol we support.
- # Don't override unless you know what you're doing (hint: incoming
- # requests are required to have exactly this version string).
- protocol_version = "HTTP/1.0"
-
- # The Message-like class used to parse headers
- MessageClass = mimetools.Message
-
- # Table mapping response codes to messages; entries have the
- # form {code: (shortmessage, longmessage)}.
- # See http://www.w3.org/hypertext/WWW/Protocols/HTTP/HTRESP.html
- responses = {
- 200: ('OK', 'Request fulfilled, document follows'),
- 201: ('Created', 'Document created, URL follows'),
- 202: ('Accepted',
- 'Request accepted, processing continues off-line'),
- 203: ('Partial information', 'Request fulfilled from cache'),
- 204: ('No response', 'Request fulfilled, nothing follows'),
-
- 301: ('Moved', 'Object moved permanently -- see URI list'),
- 302: ('Found', 'Object moved temporarily -- see URI list'),
- 303: ('Method', 'Object moved -- see Method and URL list'),
- 304: ('Not modified',
- 'Document has not changed singe given time'),
-
- 400: ('Bad request',
- 'Bad request syntax or unsupported method'),
- 401: ('Unauthorized',
- 'No permission -- see authorization schemes'),
- 402: ('Payment required',
- 'No payment -- see charging schemes'),
- 403: ('Forbidden',
- 'Request forbidden -- authorization will not help'),
- 404: ('Not found', 'Nothing matches the given URI'),
-
- 500: ('Internal error', 'Server got itself in trouble'),
- 501: ('Not implemented',
- 'Server does not support this operation'),
- 502: ('Service temporarily overloaded',
- 'The server cannot process the request due to a high load'),
- 503: ('Gateway timeout',
- 'The gateway server did not receive a timely response'),
-
- }
-
-
-def test(HandlerClass = BaseHTTPRequestHandler,
- ServerClass = HTTPServer):
- """Test the HTTP request handler class.
-
- This runs an HTTP server on port 8000 (or the first command line
- argument).
-
- """
-
- if sys.argv[1:]:
- port = string.atoi(sys.argv[1])
- else:
- port = 8000
- server_address = ('', port)
-
- httpd = ServerClass(server_address, HandlerClass)
-
- print "Serving HTTP on port", port, "..."
- httpd.serve_forever()
-
-
-if __name__ == '__main__':
- test()
diff --git a/Lib/dos-8x3/bastion.py b/Lib/dos-8x3/bastion.py
deleted file mode 100755
index a6e716b..0000000
--- a/Lib/dos-8x3/bastion.py
+++ /dev/null
@@ -1,174 +0,0 @@
-"""Bastionification utility.
-
-A bastion (for another object -- the 'original') is an object that has
-the same methods as the original but does not give access to its
-instance variables. Bastions have a number of uses, but the most
-obvious one is to provide code executing in restricted mode with a
-safe interface to an object implemented in unrestricted mode.
-
-The bastionification routine has an optional second argument which is
-a filter function. Only those methods for which the filter method
-(called with the method name as argument) returns true are accessible.
-The default filter method returns true unless the method name begins
-with an underscore.
-
-There are a number of possible implementations of bastions. We use a
-'lazy' approach where the bastion's __getattr__() discipline does all
-the work for a particular method the first time it is used. This is
-usually fastest, especially if the user doesn't call all available
-methods. The retrieved methods are stored as instance variables of
-the bastion, so the overhead is only occurred on the first use of each
-method.
-
-Detail: the bastion class has a __repr__() discipline which includes
-the repr() of the original object. This is precomputed when the
-bastion is created.
-
-"""
-
-
-from types import MethodType
-
-
-class BastionClass:
-
- """Helper class used by the Bastion() function.
-
- You could subclass this and pass the subclass as the bastionclass
- argument to the Bastion() function, as long as the constructor has
- the same signature (a get() function and a name for the object).
-
- """
-
- def __init__(self, get, name):
- """Constructor.
-
- Arguments:
-
- get - a function that gets the attribute value (by name)
- name - a human-readable name for the original object
- (suggestion: use repr(object))
-
- """
- self._get_ = get
- self._name_ = name
-
- def __repr__(self):
- """Return a representation string.
-
- This includes the name passed in to the constructor, so that
- if you print the bastion during debugging, at least you have
- some idea of what it is.
-
- """
- return "<Bastion for %s>" % self._name_
-
- def __getattr__(self, name):
- """Get an as-yet undefined attribute value.
-
- This calls the get() function that was passed to the
- constructor. The result is stored as an instance variable so
- that the next time the same attribute is requested,
- __getattr__() won't be invoked.
-
- If the get() function raises an exception, this is simply
- passed on -- exceptions are not cached.
-
- """
- attribute = self._get_(name)
- self.__dict__[name] = attribute
- return attribute
-
-
-def Bastion(object, filter = lambda name: name[:1] != '_',
- name=None, bastionclass=BastionClass):
- """Create a bastion for an object, using an optional filter.
-
- See the Bastion module's documentation for background.
-
- Arguments:
-
- object - the original object
- filter - a predicate that decides whether a function name is OK;
- by default all names are OK that don't start with '_'
- name - the name of the object; default repr(object)
- bastionclass - class used to create the bastion; default BastionClass
-
- """
-
- # Note: we define *two* ad-hoc functions here, get1 and get2.
- # Both are intended to be called in the same way: get(name).
- # It is clear that the real work (getting the attribute
- # from the object and calling the filter) is done in get1.
- # Why can't we pass get1 to the bastion? Because the user
- # would be able to override the filter argument! With get2,
- # overriding the default argument is no security loophole:
- # all it does is call it.
- # Also notice that we can't place the object and filter as
- # instance variables on the bastion object itself, since
- # the user has full access to all instance variables!
-
- def get1(name, object=object, filter=filter):
- """Internal function for Bastion(). See source comments."""
- if filter(name):
- attribute = getattr(object, name)
- if type(attribute) == MethodType:
- return attribute
- raise AttributeError, name
-
- def get2(name, get1=get1):
- """Internal function for Bastion(). See source comments."""
- return get1(name)
-
- if name is None:
- name = `object`
- return bastionclass(get2, name)
-
-
-def _test():
- """Test the Bastion() function."""
- class Original:
- def __init__(self):
- self.sum = 0
- def add(self, n):
- self._add(n)
- def _add(self, n):
- self.sum = self.sum + n
- def total(self):
- return self.sum
- o = Original()
- b = Bastion(o)
- testcode = """if 1:
- b.add(81)
- b.add(18)
- print "b.total() =", b.total()
- try:
- print "b.sum =", b.sum,
- except:
- print "inaccessible"
- else:
- print "accessible"
- try:
- print "b._add =", b._add,
- except:
- print "inaccessible"
- else:
- print "accessible"
- try:
- print "b._get_.func_defaults =", b._get_.func_defaults,
- except:
- print "inaccessible"
- else:
- print "accessible"
- \n"""
- exec testcode
- print '='*20, "Using rexec:", '='*20
- import rexec
- r = rexec.RExec()
- m = r.add_module('__main__')
- m.b = b
- r.r_exec(testcode)
-
-
-if __name__ == '__main__':
- _test()
diff --git a/Lib/dos-8x3/cgihttps.py b/Lib/dos-8x3/cgihttps.py
deleted file mode 100755
index ba1e76b..0000000
--- a/Lib/dos-8x3/cgihttps.py
+++ /dev/null
@@ -1,305 +0,0 @@
-"""CGI-savvy HTTP Server.
-
-This module builds on SimpleHTTPServer by implementing GET and POST
-requests to cgi-bin scripts.
-
-If the os.fork() function is not present (e.g. on Windows),
-os.popen2() is used as a fallback, with slightly altered semantics; if
-that function is not present either (e.g. on Macintosh), only Python
-scripts are supported, and they are executed by the current process.
-
-In all cases, the implementation is intentionally naive -- all
-requests are executed sychronously.
-
-SECURITY WARNING: DON'T USE THIS CODE UNLESS YOU ARE INSIDE A FIREWALL
--- it may execute arbitrary Python code or external programs.
-
-"""
-
-
-__version__ = "0.4"
-
-
-import os
-import sys
-import string
-import urllib
-import BaseHTTPServer
-import SimpleHTTPServer
-
-
-class CGIHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
-
- """Complete HTTP server with GET, HEAD and POST commands.
-
- GET and HEAD also support running CGI scripts.
-
- The POST command is *only* implemented for CGI scripts.
-
- """
-
- # Determine platform specifics
- have_fork = hasattr(os, 'fork')
- have_popen2 = hasattr(os, 'popen2')
-
- # Make rfile unbuffered -- we need to read one line and then pass
- # the rest to a subprocess, so we can't use buffered input.
- rbufsize = 0
-
- def do_POST(self):
- """Serve a POST request.
-
- This is only implemented for CGI scripts.
-
- """
-
- if self.is_cgi():
- self.run_cgi()
- else:
- self.send_error(501, "Can only POST to CGI scripts")
-
- def send_head(self):
- """Version of send_head that support CGI scripts"""
- if self.is_cgi():
- return self.run_cgi()
- else:
- return SimpleHTTPServer.SimpleHTTPRequestHandler.send_head(self)
-
- def is_cgi(self):
- """Test whether self.path corresponds to a CGI script.
-
- Return a tuple (dir, rest) if self.path requires running a
- CGI script, None if not. Note that rest begins with a
- slash if it is not empty.
-
- The default implementation tests whether the path
- begins with one of the strings in the list
- self.cgi_directories (and the next character is a '/'
- or the end of the string).
-
- """
-
- path = self.path
-
- for x in self.cgi_directories:
- i = len(x)
- if path[:i] == x and (not path[i:] or path[i] == '/'):
- self.cgi_info = path[:i], path[i+1:]
- return 1
- return 0
-
- cgi_directories = ['/cgi-bin', '/htbin']
-
- def is_executable(self, path):
- """Test whether argument path is an executable file."""
- return executable(path)
-
- def is_python(self, path):
- """Test whether argument path is a Python script."""
- head, tail = os.path.splitext(path)
- return tail.lower() in (".py", ".pyw")
-
- 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
- ispy = self.is_python(scriptname)
- if not ispy:
- if not (self.have_fork or self.have_popen2):
- self.send_error(403, "CGI script is not a Python script (%s)" %
- `scriptname`)
- return
- if not self.is_executable(scriptfile):
- self.send_error(403, "CGI script is not executable (%s)" %
- `scriptname`)
- return
-
- # 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]
- # XXX AUTH_TYPE
- # XXX REMOTE_USER
- # XXX REMOTE_IDENT
- if self.headers.typeheader is None:
- env['CONTENT_TYPE'] = self.headers.type
- else:
- env['CONTENT_TYPE'] = self.headers.typeheader
- 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
- co = filter(None, self.headers.getheaders('cookie'))
- if co:
- env['HTTP_COOKIE'] = string.join(co, ', ')
- # XXX Other HTTP_* headers
- if not self.have_fork:
- # Since we're setting the env in the parent, provide empty
- # values to override previously set values
- for k in ('QUERY_STRING', 'REMOTE_HOST', 'CONTENT_LENGTH',
- 'HTTP_USER_AGENT', 'HTTP_COOKIE'):
- env.setdefault(k, "")
-
- self.send_response(200, "Script output follows")
-
- decoded_query = string.replace(query, '+', ' ')
-
- if self.have_fork:
- # Unix -- fork as we should
- args = [script]
- if '=' not in decoded_query:
- args.append(decoded_query)
- nobody = nobody_uid()
- 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", sts)
- return
- # Child
- try:
- try:
- os.setuid(nobody)
- except os.error:
- pass
- os.dup2(self.rfile.fileno(), 0)
- os.dup2(self.wfile.fileno(), 1)
- os.execve(scriptfile, args, env)
- except:
- self.server.handle_error(self.request, self.client_address)
- os._exit(127)
-
- elif self.have_popen2:
- # Windows -- use popen2 to create a subprocess
- import shutil
- os.environ.update(env)
- cmdline = scriptfile
- if self.is_python(scriptfile):
- interp = sys.executable
- if interp.lower().endswith("w.exe"):
- # On Windows, use python.exe, not python.exe
- interp = interp[:-5] = interp[-4:]
- cmdline = "%s %s" % (interp, cmdline)
- if '=' not in query and '"' not in query:
- cmdline = '%s "%s"' % (cmdline, query)
- self.log_error("command: %s", cmdline)
- try:
- nbytes = int(length)
- except:
- nbytes = 0
- fi, fo = os.popen2(cmdline)
- if self.command.lower() == "post" and nbytes > 0:
- data = self.rfile.read(nbytes)
- fi.write(data)
- fi.close()
- shutil.copyfileobj(fo, self.wfile)
- sts = fo.close()
- if sts:
- self.log_error("CGI script exit status %#x", sts)
- else:
- self.log_error("CGI script exited OK")
-
- else:
- # Other O.S. -- execute script in this process
- os.environ.update(env)
- save_argv = sys.argv
- save_stdin = sys.stdin
- save_stdout = sys.stdout
- save_stderr = sys.stderr
- try:
- try:
- sys.argv = [scriptfile]
- if '=' not in decoded_query:
- sys.argv.append(decoded_query)
- sys.stdout = self.wfile
- sys.stdin = self.rfile
- execfile(scriptfile, {"__name__": "__main__"})
- finally:
- sys.argv = save_argv
- sys.stdin = save_stdin
- sys.stdout = save_stdout
- sys.stderr = save_stderr
- except SystemExit, sts:
- self.log_error("CGI script exit status %s", str(sts))
- else:
- self.log_error("CGI script exited OK")
-
-
-nobody = None
-
-def nobody_uid():
- """Internal routine to get nobody's uid"""
- global nobody
- if nobody:
- return nobody
- try:
- import pwd
- except ImportError:
- return -1
- try:
- nobody = pwd.getpwnam('nobody')[2]
- except KeyError:
- nobody = 1 + max(map(lambda x: x[2], pwd.getpwall()))
- return nobody
-
-
-def executable(path):
- """Test for executable file."""
- try:
- st = os.stat(path)
- except os.error:
- return 0
- return st[0] & 0111 != 0
-
-
-def test(HandlerClass = CGIHTTPRequestHandler,
- ServerClass = BaseHTTPServer.HTTPServer):
- SimpleHTTPServer.test(HandlerClass, ServerClass)
-
-
-if __name__ == '__main__':
- test()
diff --git a/Lib/dos-8x3/compilea.py b/Lib/dos-8x3/compilea.py
deleted file mode 100755
index e56c8b2..0000000
--- a/Lib/dos-8x3/compilea.py
+++ /dev/null
@@ -1,128 +0,0 @@
-"""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 stat
-import sys
-import py_compile
-
-def compile_dir(dir, maxlevels=10, ddir=None, force=0):
- """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)
- force: if 1, force compilation, even if timestamps are up-to-date
-
- """
- print 'Listing', dir, '...'
- try:
- names = os.listdir(dir)
- except os.error:
- print "Can't list", dir
- names = []
- names.sort()
- success = 1
- 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':
- cfile = fullname + (__debug__ and 'c' or 'o')
- ftime = os.stat(fullname)[stat.ST_MTIME]
- try: ctime = os.stat(cfile)[stat.ST_MTIME]
- except os.error: ctime = 0
- if (ctime > ftime) and not force: continue
- 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
- success = 0
- 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, force)
- return success
-
-def compile_path(skip_curdir=1, maxlevels=0, force=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)
- force: as for compile_dir() (default 0)
-
- """
- success = 1
- for dir in sys.path:
- if (not dir or dir == os.curdir) and skip_curdir:
- print 'Skipping current directory'
- else:
- success = success and compile_dir(dir, maxlevels, None, force)
- return success
-
-def main():
- """Script main program."""
- import getopt
- try:
- opts, args = getopt.getopt(sys.argv[1:], 'lfd:')
- except getopt.error, msg:
- print msg
- print "usage: compileall [-l] [-f] [-d destdir] [directory ...]"
- print "-l: don't recurse down"
- print "-f: force rebuild even if timestamps are up-to-date"
- print "-d destdir: purported directory name for error messages"
- print "if no directory arguments, -l sys.path is assumed"
- sys.exit(2)
- maxlevels = 10
- ddir = None
- force = 0
- for o, a in opts:
- if o == '-l': maxlevels = 0
- if o == '-d': ddir = a
- if o == '-f': force = 1
- if ddir:
- if len(args) != 1:
- print "-d destdir require exactly one directory argument"
- sys.exit(2)
- success = 1
- try:
- if args:
- for dir in args:
- success = success and compile_dir(dir, maxlevels, ddir, force)
- else:
- success = compile_path()
- except KeyboardInterrupt:
- print "\n[interrupt]"
- success = 0
- return success
-
-if __name__ == '__main__':
- sys.exit(not main())
diff --git a/Lib/dos-8x3/configpa.py b/Lib/dos-8x3/configpa.py
deleted file mode 100644
index 5043687..0000000
--- a/Lib/dos-8x3/configpa.py
+++ /dev/null
@@ -1,469 +0,0 @@
-"""Configuration file parser.
-
-A setup file consists of sections, lead by a "[section]" header,
-and followed by "name: value" entries, with continuations and such in
-the style of RFC 822.
-
-The option values can contain format strings which refer to other values in
-the same section, or values in a special [DEFAULT] section.
-
-For example:
-
- something: %(dir)s/whatever
-
-would resolve the "%(dir)s" to the value of dir. All reference
-expansions are done late, on demand.
-
-Intrinsic defaults can be specified by passing them into the
-ConfigParser constructor as a dictionary.
-
-class:
-
-ConfigParser -- responsible for for parsing a list of
- configuration files, and managing the parsed database.
-
- methods:
-
- __init__(defaults=None)
- create the parser and specify a dictionary of intrinsic defaults. The
- keys must be strings, the values must be appropriate for %()s string
- interpolation. Note that `__name__' is always an intrinsic default;
- it's value is the section's name.
-
- sections()
- return all the configuration section names, sans DEFAULT
-
- has_section(section)
- return whether the given section exists
-
- has_option(section, option)
- return whether the given option exists in the given section
-
- options(section)
- return list of configuration options for the named section
-
- has_option(section, option)
- return whether the given section has the given option
-
- read(filenames)
- read and parse the list of named configuration files, given by
- name. A single filename is also allowed. Non-existing files
- are ignored.
-
- readfp(fp, filename=None)
- read and parse one configuration file, given as a file object.
- The filename defaults to fp.name; it is only used in error
- messages (if fp has no `name' attribute, the string `<???>' is used).
-
- get(section, option, raw=0, vars=None)
- 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. Additional substitutions may be
- provided using the `vars' argument, which must be a dictionary whose
- contents override any pre-existing defaults.
-
- 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)
-
- remove_section(section)
- remove the given file section and all its options
-
- remove_option(section, option)
- remove the given option from the given section
-
- set(section, option, value)
- set the given option
-
- write(fp)
- write the configuration state in .ini format
-"""
-
-import sys
-import string
-import re
-
-DEFAULTSECT = "DEFAULT"
-
-MAX_INTERPOLATION_DEPTH = 10
-
-
-
-# exception classes
-class Error:
- def __init__(self, msg=''):
- self._msg = msg
- def __repr__(self):
- return self._msg
-
-class NoSectionError(Error):
- def __init__(self, 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
-
-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
-
-class InterpolationError(Error):
- def __init__(self, reference, option, section, rawval):
- Error.__init__(self,
- "Bad value substitution:\n"
- "\tsection: [%s]\n"
- "\toption : %s\n"
- "\tkey : %s\n"
- "\trawval : %s\n"
- % (section, option, reference, rawval))
- self.reference = reference
- self.option = option
- self.section = section
-
-class InterpolationDepthError(Error):
- def __init__(self, option, section, rawval):
- Error.__init__(self,
- "Value interpolation too deeply recursive:\n"
- "\tsection: [%s]\n"
- "\toption : %s\n"
- "\trawval : %s\n"
- % (section, option, rawval))
- self.option = option
- self.section = section
-
-class ParsingError(Error):
- def __init__(self, filename):
- Error.__init__(self, 'File contains parsing errors: %s' % filename)
- self.filename = filename
- self.errors = []
-
- def append(self, lineno, line):
- self.errors.append((lineno, line))
- self._msg = self._msg + '\n\t[line %2d]: %s' % (lineno, line)
-
-class MissingSectionHeaderError(ParsingError):
- def __init__(self, filename, lineno, line):
- Error.__init__(
- self,
- 'File contains no section headers.\nfile: %s, line: %d\n%s' %
- (filename, lineno, line))
- self.filename = filename
- self.lineno = lineno
- self.line = line
-
-
-
-class ConfigParser:
- def __init__(self, defaults=None):
- self.__sections = {}
- if defaults is None:
- self.__defaults = {}
- else:
- self.__defaults = defaults
-
- def defaults(self):
- 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()
-
- def add_section(self, section):
- """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] = {}
-
- def has_section(self, section):
- """Indicate whether the named section is present in the configuration.
-
- The DEFAULT section is not acknowledged.
- """
- return section in self.sections()
-
- def options(self, section):
- """Return a list of option names for the given section name."""
- try:
- opts = self.__sections[section].copy()
- except KeyError:
- raise NoSectionError(section)
- opts.update(self.__defaults)
- if opts.has_key('__name__'):
- del opts['__name__']
- return opts.keys()
-
- def has_option(self, section, option):
- """Return whether the given section has the given option."""
- return option in self.options(section)
-
- def read(self, filenames):
- """Read and parse a filename or a list of filenames.
-
- Files that cannot be opened are silently ignored; this is
- designed so that you can specify a list of potential
- configuration file locations (e.g. current directory, user's
- home directory, systemwide directory), and all existing
- configuration files in the list will be read. A single
- filename may also be given.
- """
- if type(filenames) in [type(''), type(u'')]:
- filenames = [filenames]
- for filename in filenames:
- try:
- fp = open(filename)
- except IOError:
- continue
- self.__read(fp, filename)
- fp.close()
-
- def readfp(self, fp, filename=None):
- """Like read() but the argument must be a file-like object.
-
- The `fp' argument must have a `readline' method. Optional
- second argument is the `filename', which if not given, is
- taken from fp.name. If fp has no `name' attribute, `<???>' is
- used.
-
- """
- if filename is None:
- try:
- filename = fp.name
- except AttributeError:
- filename = '<???>'
- self.__read(fp, filename)
-
- def get(self, section, option, raw=0, vars=None):
- """Get an option value for a given section.
-
- All % interpolations are expanded in the return values, based on the
- defaults passed into the constructor, unless the optional argument
- `raw' is true. Additional substitutions may be provided using the
- `vars' argument, which must be a dictionary whose contents overrides
- any pre-existing defaults.
-
- 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)
- # Update with the entry specific variables
- if vars:
- d.update(vars)
- option = self.optionxform(option)
- try:
- rawval = d[option]
- except KeyError:
- raise NoOptionError(option, section)
-
- if raw:
- return rawval
-
- # do the string interpolation
- value = rawval # Make it a pretty variable name
- depth = 0
- while depth < 10: # Loop through this until it's done
- depth = depth + 1
- if string.find(value, "%(") >= 0:
- try:
- value = value % d
- except KeyError, key:
- raise InterpolationError(key, option, section, rawval)
- else:
- break
- if value.find("%(") >= 0:
- raise InterpolationDepthError(option, section, rawval)
- return value
-
- def __get(self, section, conv, option):
- return conv(self.get(section, option))
-
- def getint(self, section, option):
- return self.__get(section, string.atoi, option)
-
- def getfloat(self, section, 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
-
- def optionxform(self, optionstr):
- return string.lower(optionstr)
-
- def has_option(self, section, option):
- """Check for the existence of a given option in a given section."""
- if not section or section == "DEFAULT":
- return self.__defaults.has_key(option)
- elif not self.has_section(section):
- return 0
- else:
- return self.__sections[section].has_key(option)
-
- def set(self, section, option, value):
- """Set an option."""
- if not section or section == "DEFAULT":
- sectdict = self.__defaults
- else:
- try:
- sectdict = self.__sections[section]
- except KeyError:
- raise NoSectionError(section)
- sectdict[option] = value
-
- def write(self, fp):
- """Write an .ini-format representation of the configuration state."""
- if self.__defaults:
- fp.write("[DEFAULT]\n")
- for (key, value) in self.__defaults.items():
- fp.write("%s = %s\n" % (key, value))
- fp.write("\n")
- for section in self.sections():
- fp.write("[" + section + "]\n")
- sectdict = self.__sections[section]
- for (key, value) in sectdict.items():
- if key == "__name__":
- continue
- fp.write("%s = %s\n" % (key, value))
- fp.write("\n")
-
- def remove_option(self, section, option):
- """Remove an option."""
- if not section or section == "DEFAULT":
- sectdict = self.__defaults
- else:
- try:
- sectdict = self.__sections[section]
- except KeyError:
- raise NoSectionError(section)
- existed = sectdict.has_key(key)
- if existed:
- del sectdict[key]
- return existed
-
- def remove_section(self, section):
- """Remove a file section."""
- if self.__sections.has_key(section):
- del self.__sections[section]
- return 1
- else:
- return 0
-
- #
- # Regular expressions for parsing section headers and options. Note a
- # slight semantic change from the previous version, because of the use
- # of \w, _ is allowed in section header names.
- SECTCRE = re.compile(
- r'\[' # [
- r'(?P<header>[-\w_.*,(){} ]+)' # a lot of stuff found by IvL
- r'\]' # ]
- )
- OPTCRE = re.compile(
- r'(?P<option>[-\w_.*,(){}]+)' # a lot of stuff found by IvL
- r'[ \t]*(?P<vi>[:=])[ \t]*' # any number of space/tab,
- # followed by separator
- # (either : or =), followed
- # by any # space/tab
- r'(?P<value>.*)$' # everything up to eol
- )
-
- def __read(self, fp, fpname):
- """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
- e = None # None, or an exception
- 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] in "rR": # no leading whitespace
- continue
- # continuation line?
- if line[0] in ' \t' and cursect is not None and optname:
- value = string.strip(line)
- if value:
- cursect[optname] = cursect[optname] + '\n ' + value
- # a section header or option header?
- else:
- # is it a section header?
- mo = self.SECTCRE.match(line)
- if mo:
- sectname = mo.group('header')
- 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
- # no section header in the file?
- elif cursect is None:
- raise MissingSectionHeaderError(fpname, lineno, `line`)
- # an option line?
- else:
- mo = self.OPTCRE.match(line)
- if mo:
- optname, vi, optval = mo.group('option', 'vi', 'value')
- if vi in ('=', ':') and ';' in optval:
- # ';' is a comment delimiter only if it follows
- # a spacing character
- pos = string.find(optval, ';')
- if pos and optval[pos-1] in string.whitespace:
- optval = optval[:pos]
- optval = string.strip(optval)
- # allow empty values
- if optval == '""':
- optval = ''
- cursect[self.optionxform(optname)] = optval
- else:
- # a non-fatal parsing error occurred. set up the
- # exception but keep going. the exception will be
- # raised at the end of the file and will contain a
- # list of all bogus lines
- if not e:
- e = ParsingError(fpname)
- e.append(lineno, `line`)
- # if any parsing errors occurred, raise an exception
- if e:
- raise e
diff --git a/Lib/dos-8x3/cookie.py b/Lib/dos-8x3/cookie.py
deleted file mode 100644
index 67259af..0000000
--- a/Lib/dos-8x3/cookie.py
+++ /dev/null
@@ -1,726 +0,0 @@
-#!/usr/bin/env python
-#
-
-####
-# Copyright 2000 by Timothy O'Malley <timo@alum.mit.edu>
-#
-# All Rights Reserved
-#
-# Permission to use, copy, modify, and distribute this software
-# and its documentation for any purpose and without fee is hereby
-# granted, provided that the above copyright notice appear in all
-# copies and that both that copyright notice and this permission
-# notice appear in supporting documentation, and that the name of
-# Timothy O'Malley not be used in advertising or publicity
-# pertaining to distribution of the software without specific, written
-# prior permission.
-#
-# Timothy O'Malley DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
-# SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-# AND FITNESS, IN NO EVENT SHALL Timothy O'Malley BE LIABLE FOR
-# ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
-# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
-# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-# PERFORMANCE OF THIS SOFTWARE.
-#
-####
-#
-# Id: Cookie.py,v 2.29 2000/08/23 05:28:49 timo Exp
-# by Timothy O'Malley <timo@alum.mit.edu>
-#
-# Cookie.py is a Python module for the handling of HTTP
-# cookies as a Python dictionary. See RFC 2109 for more
-# information on cookies.
-#
-# The original idea to treat Cookies as a dictionary came from
-# Dave Mitchell (davem@magnet.com) in 1995, when he released the
-# first version of nscookie.py.
-#
-####
-
-"""
-Here's a sample session to show how to use this module.
-At the moment, this is the only documentation.
-
-The Basics
-----------
-
-Importing is easy..
-
- >>> import Cookie
-
-Most of the time you start by creating a cookie. Cookies come in
-three flavors, each with slighly different encoding semanitcs, but
-more on that later.
-
- >>> C = Cookie.SimpleCookie()
- >>> C = Cookie.SerialCookie()
- >>> C = Cookie.SmartCookie()
-
-[Note: Long-time users of Cookie.py will remember using
-Cookie.Cookie() to create an Cookie object. Although deprecated, it
-is still supported by the code. See the Backward Compatibility notes
-for more information.]
-
-Once you've created your Cookie, you can add values just as if it were
-a dictionary.
-
- >>> C = Cookie.SmartCookie()
- >>> C["fig"] = "newton"
- >>> C["sugar"] = "wafer"
- >>> print C
- Set-Cookie: sugar=wafer;
- Set-Cookie: fig=newton;
-
-Notice that the printable representation of a Cookie is the
-appropriate format for a Set-Cookie: header. This is the
-default behavior. You can change the header and printed
-attributes by using the the .output() function
-
- >>> C = Cookie.SmartCookie()
- >>> C["rocky"] = "road"
- >>> C["rocky"]["path"] = "/cookie"
- >>> print C.output(header="Cookie:")
- Cookie: rocky=road; Path=/cookie;
- >>> print C.output(attrs=[], header="Cookie:")
- Cookie: rocky=road;
-
-The load() method of a Cookie extracts cookies from a string. In a
-CGI script, you would use this method to extract the cookies from the
-HTTP_COOKIE environment variable.
-
- >>> C = Cookie.SmartCookie()
- >>> C.load("chips=ahoy; vienna=finger")
- >>> print C
- Set-Cookie: vienna=finger;
- Set-Cookie: chips=ahoy;
-
-The load() method is darn-tootin smart about identifying cookies
-within a string. Escaped quotation marks, nested semicolons, and other
-such trickeries do not confuse it.
-
- >>> C = Cookie.SmartCookie()
- >>> C.load('keebler="E=everybody; L=\\"Loves\\"; fudge=\\012;";')
- >>> print C
- Set-Cookie: keebler="E=everybody; L=\"Loves\"; fudge=\012;";
-
-Each element of the Cookie also supports all of the RFC 2109
-Cookie attributes. Here's an example which sets the Path
-attribute.
-
- >>> C = Cookie.SmartCookie()
- >>> C["oreo"] = "doublestuff"
- >>> C["oreo"]["path"] = "/"
- >>> print C
- Set-Cookie: oreo="doublestuff"; Path=/;
-
-Each dictionary element has a 'value' attribute, which gives you
-back the value associated with the key.
-
- >>> C = Cookie.SmartCookie()
- >>> C["twix"] = "none for you"
- >>> C["twix"].value
- 'none for you'
-
-
-A Bit More Advanced
--------------------
-
-As mentioned before, there are three different flavors of Cookie
-objects, each with different encoding/decoding semantics. This
-section briefly discusses the differences.
-
-SimpleCookie
-
-The SimpleCookie expects that all values should be standard strings.
-Just to be sure, SimpleCookie invokes the str() builtin to convert
-the value to a string, when the values are set dictionary-style.
-
- >>> C = Cookie.SimpleCookie()
- >>> C["number"] = 7
- >>> C["string"] = "seven"
- >>> C["number"].value
- '7'
- >>> C["string"].value
- 'seven'
- >>> print C
- Set-Cookie: number=7;
- Set-Cookie: string=seven;
-
-
-SerialCookie
-
-The SerialCookie expects that all values should be serialized using
-cPickle (or pickle, if cPickle isn't available). As a result of
-serializing, SerialCookie can save almost any Python object to a
-value, and recover the exact same object when the cookie has been
-returned. (SerialCookie can yield some strange-looking cookie
-values, however.)
-
- >>> C = Cookie.SerialCookie()
- >>> C["number"] = 7
- >>> C["string"] = "seven"
- >>> C["number"].value
- 7
- >>> C["string"].value
- 'seven'
- >>> print C
- Set-Cookie: number="I7\012.";
- Set-Cookie: string="S'seven'\012p1\012.";
-
-Be warned, however, if SerialCookie cannot de-serialize a value (because
-it isn't a valid pickle'd object), IT WILL RAISE AN EXCEPTION.
-
-
-SmartCookie
-
-The SmartCookie combines aspects of each of the other two flavors.
-When setting a value in a dictionary-fashion, the SmartCookie will
-serialize (ala cPickle) the value *if and only if* it isn't a
-Python string. String objects are *not* serialized. Similarly,
-when the load() method parses out values, it attempts to de-serialize
-the value. If it fails, then it fallsback to treating the value
-as a string.
-
- >>> C = Cookie.SmartCookie()
- >>> C["number"] = 7
- >>> C["string"] = "seven"
- >>> C["number"].value
- 7
- >>> C["string"].value
- 'seven'
- >>> print C
- Set-Cookie: number="I7\012.";
- Set-Cookie: string=seven;
-
-
-Backwards Compatibility
------------------------
-
-In order to keep compatibilty with earlier versions of Cookie.py,
-it is still possible to use Cookie.Cookie() to create a Cookie. In
-fact, this simply returns a SmartCookie.
-
- >>> C = Cookie.Cookie()
- >>> C.__class__
- <class Cookie.SmartCookie at 99f88>
-
-
-Finis.
-""" #"
-# ^
-# |----helps out font-lock
-
-#
-# Import our required modules
-#
-import string, sys
-from UserDict import UserDict
-
-try:
- from cPickle import dumps, loads
-except ImportError:
- from pickle import dumps, loads
-
-try:
- import re
-except ImportError:
- raise ImportError, "Cookie.py requires 're' from Python 1.5 or later"
-
-
-#
-# Define an exception visible to External modules
-#
-class CookieError(Exception):
- pass
-
-
-# These quoting routines conform to the RFC2109 specification, which in
-# turn references the character definitions from RFC2068. They provide
-# a two-way quoting algorithm. Any non-text character is translated
-# into a 4 character sequence: a forward-slash followed by the
-# three-digit octal equivalent of the character. Any '\' or '"' is
-# quoted with a preceeding '\' slash.
-#
-# These are taken from RFC2068 and RFC2109.
-# _LegalChars is the list of chars which don't require "'s
-# _Translator hash-table for fast quoting
-#
-_LegalChars = string.letters + string.digits + "!#$%&'*+-.^_`|~"
-_Translator = {
- '\000' : '\\000', '\001' : '\\001', '\002' : '\\002',
- '\003' : '\\003', '\004' : '\\004', '\005' : '\\005',
- '\006' : '\\006', '\007' : '\\007', '\010' : '\\010',
- '\011' : '\\011', '\012' : '\\012', '\013' : '\\013',
- '\014' : '\\014', '\015' : '\\015', '\016' : '\\016',
- '\017' : '\\017', '\020' : '\\020', '\021' : '\\021',
- '\022' : '\\022', '\023' : '\\023', '\024' : '\\024',
- '\025' : '\\025', '\026' : '\\026', '\027' : '\\027',
- '\030' : '\\030', '\031' : '\\031', '\032' : '\\032',
- '\033' : '\\033', '\034' : '\\034', '\035' : '\\035',
- '\036' : '\\036', '\037' : '\\037',
-
- '"' : '\\"', '\\' : '\\\\',
-
- '\177' : '\\177', '\200' : '\\200', '\201' : '\\201',
- '\202' : '\\202', '\203' : '\\203', '\204' : '\\204',
- '\205' : '\\205', '\206' : '\\206', '\207' : '\\207',
- '\210' : '\\210', '\211' : '\\211', '\212' : '\\212',
- '\213' : '\\213', '\214' : '\\214', '\215' : '\\215',
- '\216' : '\\216', '\217' : '\\217', '\220' : '\\220',
- '\221' : '\\221', '\222' : '\\222', '\223' : '\\223',
- '\224' : '\\224', '\225' : '\\225', '\226' : '\\226',
- '\227' : '\\227', '\230' : '\\230', '\231' : '\\231',
- '\232' : '\\232', '\233' : '\\233', '\234' : '\\234',
- '\235' : '\\235', '\236' : '\\236', '\237' : '\\237',
- '\240' : '\\240', '\241' : '\\241', '\242' : '\\242',
- '\243' : '\\243', '\244' : '\\244', '\245' : '\\245',
- '\246' : '\\246', '\247' : '\\247', '\250' : '\\250',
- '\251' : '\\251', '\252' : '\\252', '\253' : '\\253',
- '\254' : '\\254', '\255' : '\\255', '\256' : '\\256',
- '\257' : '\\257', '\260' : '\\260', '\261' : '\\261',
- '\262' : '\\262', '\263' : '\\263', '\264' : '\\264',
- '\265' : '\\265', '\266' : '\\266', '\267' : '\\267',
- '\270' : '\\270', '\271' : '\\271', '\272' : '\\272',
- '\273' : '\\273', '\274' : '\\274', '\275' : '\\275',
- '\276' : '\\276', '\277' : '\\277', '\300' : '\\300',
- '\301' : '\\301', '\302' : '\\302', '\303' : '\\303',
- '\304' : '\\304', '\305' : '\\305', '\306' : '\\306',
- '\307' : '\\307', '\310' : '\\310', '\311' : '\\311',
- '\312' : '\\312', '\313' : '\\313', '\314' : '\\314',
- '\315' : '\\315', '\316' : '\\316', '\317' : '\\317',
- '\320' : '\\320', '\321' : '\\321', '\322' : '\\322',
- '\323' : '\\323', '\324' : '\\324', '\325' : '\\325',
- '\326' : '\\326', '\327' : '\\327', '\330' : '\\330',
- '\331' : '\\331', '\332' : '\\332', '\333' : '\\333',
- '\334' : '\\334', '\335' : '\\335', '\336' : '\\336',
- '\337' : '\\337', '\340' : '\\340', '\341' : '\\341',
- '\342' : '\\342', '\343' : '\\343', '\344' : '\\344',
- '\345' : '\\345', '\346' : '\\346', '\347' : '\\347',
- '\350' : '\\350', '\351' : '\\351', '\352' : '\\352',
- '\353' : '\\353', '\354' : '\\354', '\355' : '\\355',
- '\356' : '\\356', '\357' : '\\357', '\360' : '\\360',
- '\361' : '\\361', '\362' : '\\362', '\363' : '\\363',
- '\364' : '\\364', '\365' : '\\365', '\366' : '\\366',
- '\367' : '\\367', '\370' : '\\370', '\371' : '\\371',
- '\372' : '\\372', '\373' : '\\373', '\374' : '\\374',
- '\375' : '\\375', '\376' : '\\376', '\377' : '\\377'
- }
-
-def _quote(str, LegalChars=_LegalChars,
- join=string.join, idmap=string._idmap, translate=string.translate):
- #
- # If the string does not need to be double-quoted,
- # then just return the string. Otherwise, surround
- # the string in doublequotes and precede quote (with a \)
- # special characters.
- #
- if "" == translate(str, idmap, LegalChars):
- return str
- else:
- return '"' + join( map(_Translator.get, str, str), "" ) + '"'
-# end _quote
-
-
-_OctalPatt = re.compile(r"\\[0-3][0-7][0-7]")
-_QuotePatt = re.compile(r"[\\].")
-
-def _unquote(str, join=string.join, atoi=string.atoi):
- # If there aren't any doublequotes,
- # then there can't be any special characters. See RFC 2109.
- if len(str) < 2:
- return str
- if str[0] != '"' or str[-1] != '"':
- return str
-
- # We have to assume that we must decode this string.
- # Down to work.
-
- # Remove the "s
- str = str[1:-1]
-
- # Check for special sequences. Examples:
- # \012 --> \n
- # \" --> "
- #
- i = 0
- n = len(str)
- res = []
- while 0 <= i < n:
- Omatch = _OctalPatt.search(str, i)
- Qmatch = _QuotePatt.search(str, i)
- if not Omatch and not Qmatch: # Neither matched
- res.append(str[i:])
- break
- # else:
- j = k = -1
- if Omatch: j = Omatch.start(0)
- if Qmatch: k = Qmatch.start(0)
- if Qmatch and ( not Omatch or k < j ): # QuotePatt matched
- res.append(str[i:k])
- res.append(str[k+1])
- i = k+2
- else: # OctalPatt matched
- res.append(str[i:j])
- res.append( chr( atoi(str[j+1:j+4], 8) ) )
- i = j+4
- return join(res, "")
-# end _unquote
-
-# The _getdate() routine is used to set the expiration time in
-# the cookie's HTTP header. By default, _getdate() returns the
-# current time in the appropriate "expires" format for a
-# Set-Cookie header. The one optional argument is an offset from
-# now, in seconds. For example, an offset of -3600 means "one hour ago".
-# The offset may be a floating point number.
-#
-
-_weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
-
-_monthname = [None,
- 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
- 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
-
-def _getdate(future=0, weekdayname=_weekdayname, monthname=_monthname):
- from time import gmtime, time
- now = time()
- year, month, day, hh, mm, ss, wd, y, z = gmtime(now + future)
- return "%s, %02d-%3s-%4d %02d:%02d:%02d GMT" % \
- (weekdayname[wd], day, monthname[month], year, hh, mm, ss)
-
-
-#
-# A class to hold ONE key,value pair.
-# In a cookie, each such pair may have several attributes.
-# so this class is used to keep the attributes associated
-# with the appropriate key,value pair.
-# This class also includes a coded_value attribute, which
-# is used to hold the network representation of the
-# value. This is most useful when Python objects are
-# pickled for network transit.
-#
-
-class Morsel(UserDict):
- # RFC 2109 lists these attributes as reserved:
- # path comment domain
- # max-age secure version
- #
- # For historical reasons, these attributes are also reserved:
- # expires
- #
- # This dictionary provides a mapping from the lowercase
- # variant on the left to the appropriate traditional
- # formatting on the right.
- _reserved = { "expires" : "expires",
- "path" : "Path",
- "comment" : "Comment",
- "domain" : "Domain",
- "max-age" : "Max-Age",
- "secure" : "secure",
- "version" : "Version",
- }
- _reserved_keys = _reserved.keys()
-
- def __init__(self):
- # Set defaults
- self.key = self.value = self.coded_value = None
- UserDict.__init__(self)
-
- # Set default attributes
- for K in self._reserved_keys:
- UserDict.__setitem__(self, K, "")
- # end __init__
-
- def __setitem__(self, K, V):
- K = string.lower(K)
- if not K in self._reserved_keys:
- raise CookieError("Invalid Attribute %s" % K)
- UserDict.__setitem__(self, K, V)
- # end __setitem__
-
- def isReservedKey(self, K):
- return string.lower(K) in self._reserved_keys
- # end isReservedKey
-
- def set(self, key, val, coded_val,
- LegalChars=_LegalChars,
- idmap=string._idmap, translate=string.translate ):
- # First we verify that the key isn't a reserved word
- # Second we make sure it only contains legal characters
- if string.lower(key) in self._reserved_keys:
- raise CookieError("Attempt to set a reserved key: %s" % key)
- if "" != translate(key, idmap, LegalChars):
- raise CookieError("Illegal key value: %s" % key)
-
- # It's a good key, so save it.
- self.key = key
- self.value = val
- self.coded_value = coded_val
- # end set
-
- def output(self, attrs=None, header = "Set-Cookie:"):
- return "%s %s" % ( header, self.OutputString(attrs) )
-
- __str__ = output
-
- def __repr__(self):
- return '<%s: %s=%s>' % (self.__class__.__name__,
- self.key, repr(self.value) )
-
- def js_output(self, attrs=None):
- # Print javascript
- return """
- <SCRIPT LANGUAGE="JavaScript">
- <!-- begin hiding
- document.cookie = \"%s\"
- // end hiding -->
- </script>
- """ % ( self.OutputString(attrs), )
- # end js_output()
-
- def OutputString(self, attrs=None):
- # Build up our result
- #
- result = []
- RA = result.append
-
- # First, the key=value pair
- RA("%s=%s;" % (self.key, self.coded_value))
-
- # Now add any defined attributes
- if attrs == None:
- attrs = self._reserved_keys
- for K,V in self.items():
- if V == "": continue
- if K not in attrs: continue
- if K == "expires" and type(V) == type(1):
- RA("%s=%s;" % (self._reserved[K], _getdate(V)))
- elif K == "max-age" and type(V) == type(1):
- RA("%s=%d;" % (self._reserved[K], V))
- elif K == "secure":
- RA("%s;" % self._reserved[K])
- else:
- RA("%s=%s;" % (self._reserved[K], V))
-
- # Return the result
- return string.join(result, " ")
- # end OutputString
-# end Morsel class
-
-
-
-#
-# Pattern for finding cookie
-#
-# This used to be strict parsing based on the RFC2109 and RFC2068
-# specifications. I have since discovered that MSIE 3.0x doesn't
-# follow the character rules outlined in those specs. As a
-# result, the parsing rules here are less strict.
-#
-
-_LegalCharsPatt = r"[\w\d!#%&'~_`><@,:/\$\*\+\-\.\^\|\)\(\?\}\{]"
-_CookiePattern = re.compile(
- r"(?x)" # This is a Verbose pattern
- r"(?P<key>" # Start of group 'key'
- ""+ _LegalCharsPatt +"+" # Any word of at least one letter
- r")" # End of group 'key'
- r"\s*=\s*" # Equal Sign
- r"(?P<val>" # Start of group 'val'
- r'"(?:[^\\"]|\\.)*"' # Any doublequoted string
- r"|" # or
- ""+ _LegalCharsPatt +"*" # Any word or empty string
- r")" # End of group 'val'
- r"\s*;?" # Probably ending in a semi-colon
- )
-
-
-# At long last, here is the cookie class.
-# Using this class is almost just like using a dictionary.
-# See this module's docstring for example usage.
-#
-class BaseCookie(UserDict):
- # A container class for a set of Morsels
- #
-
- def value_decode(self, val):
- """real_value, coded_value = value_decode(STRING)
- Called prior to setting a cookie's value from the network
- representation. The VALUE is the value read from HTTP
- header.
- Override this function to modify the behavior of cookies.
- """
- return val, val
- # end value_encode
-
- def value_encode(self, val):
- """real_value, coded_value = value_encode(VALUE)
- Called prior to setting a cookie's value from the dictionary
- representation. The VALUE is the value being assigned.
- Override this function to modify the behavior of cookies.
- """
- strval = str(val)
- return strval, strval
- # end value_encode
-
- def __init__(self, input=None):
- UserDict.__init__(self)
- if input: self.load(input)
- # end __init__
-
- def __set(self, key, real_value, coded_value):
- """Private method for setting a cookie's value"""
- M = self.get(key, Morsel())
- M.set(key, real_value, coded_value)
- UserDict.__setitem__(self, key, M)
- # end __set
-
- def __setitem__(self, key, value):
- """Dictionary style assignment."""
- rval, cval = self.value_encode(value)
- self.__set(key, rval, cval)
- # end __setitem__
-
- def output(self, attrs=None, header="Set-Cookie:", sep="\n"):
- """Return a string suitable for HTTP."""
- result = []
- for K,V in self.items():
- result.append( V.output(attrs, header) )
- return string.join(result, sep)
- # end output
-
- __str__ = output
-
- def __repr__(self):
- L = []
- for K,V in self.items():
- L.append( '%s=%s' % (K,repr(V.value) ) )
- return '<%s: %s>' % (self.__class__.__name__, string.join(L))
-
- def js_output(self, attrs=None):
- """Return a string suitable for JavaScript."""
- result = []
- for K,V in self.items():
- result.append( V.js_output(attrs) )
- return string.join(result, "")
- # end js_output
-
- def load(self, rawdata):
- """Load cookies from a string (presumably HTTP_COOKIE) or
- from a dictionary. Loading cookies from a dictionary 'd'
- is equivalent to calling:
- map(Cookie.__setitem__, d.keys(), d.values())
- """
- if type(rawdata) == type(""):
- self.__ParseString(rawdata)
- else:
- self.update(rawdata)
- return
- # end load()
-
- def __ParseString(self, str, patt=_CookiePattern):
- i = 0 # Our starting point
- n = len(str) # Length of string
- M = None # current morsel
-
- while 0 <= i < n:
- # Start looking for a cookie
- match = patt.search(str, i)
- if not match: break # No more cookies
-
- K,V = match.group("key"), match.group("val")
- i = match.end(0)
-
- # Parse the key, value in case it's metainfo
- if K[0] == "$":
- # We ignore attributes which pertain to the cookie
- # mechanism as a whole. See RFC 2109.
- # (Does anyone care?)
- if M:
- M[ K[1:] ] = V
- elif string.lower(K) in Morsel._reserved_keys:
- if M:
- M[ K ] = _unquote(V)
- else:
- rval, cval = self.value_decode(V)
- self.__set(K, rval, cval)
- M = self[K]
- # end __ParseString
-# end BaseCookie class
-
-class SimpleCookie(BaseCookie):
- """SimpleCookie
- SimpleCookie supports strings as cookie values. When setting
- the value using the dictionary assignment notation, SimpleCookie
- calls the builtin str() to convert the value to a string. Values
- received from HTTP are kept as strings.
- """
- def value_decode(self, val):
- return _unquote( val ), val
- def value_encode(self, val):
- strval = str(val)
- return strval, _quote( strval )
-# end SimpleCookie
-
-class SerialCookie(BaseCookie):
- """SerialCookie
- SerialCookie supports arbitrary objects as cookie values. All
- values are serialized (using cPickle) before being sent to the
- client. All incoming values are assumed to be valid Pickle
- representations. IF AN INCOMING VALUE IS NOT IN A VALID PICKLE
- FORMAT, THEN AN EXCEPTION WILL BE RAISED.
-
- Note: Large cookie values add overhead because they must be
- retransmitted on every HTTP transaction.
-
- Note: HTTP has a 2k limit on the size of a cookie. This class
- does not check for this limit, so be careful!!!
- """
- def value_decode(self, val):
- # This could raise an exception!
- return loads( _unquote(val) ), val
- def value_encode(self, val):
- return val, _quote( dumps(val) )
-# end SerialCookie
-
-class SmartCookie(BaseCookie):
- """SmartCookie
- SmartCookie supports arbitrary objects as cookie values. If the
- object is a string, then it is quoted. If the object is not a
- string, however, then SmartCookie will use cPickle to serialize
- the object into a string representation.
-
- Note: Large cookie values add overhead because they must be
- retransmitted on every HTTP transaction.
-
- Note: HTTP has a 2k limit on the size of a cookie. This class
- does not check for this limit, so be careful!!!
- """
- def value_decode(self, val):
- strval = _unquote(val)
- try:
- return loads(strval), val
- except:
- return strval, val
- def value_encode(self, val):
- if type(val) == type(""):
- return val, _quote(val)
- else:
- return val, _quote( dumps(val) )
-# end SmartCookie
-
-
-###########################################################
-# Backwards Compatibility: Don't break any existing code!
-
-# We provide Cookie() as an alias for SmartCookie()
-Cookie = SmartCookie
-
-#
-###########################################################
-
-
-
-#Local Variables:
-#tab-width: 4
-#end:
diff --git a/Lib/dos-8x3/fileinpu.py b/Lib/dos-8x3/fileinpu.py
deleted file mode 100644
index d1b7617..0000000
--- a/Lib/dos-8x3/fileinpu.py
+++ /dev/null
@@ -1,268 +0,0 @@
-"""Helper class to quickly write a loop over all standard input files.
-
-Typical use is:
-
- import fileinput
- for line in fileinput.input():
- process(line)
-
-This iterates over the lines of all files listed in sys.argv[1:],
-defaulting to sys.stdin if the list is empty. If a filename is '-' it
-is also replaced by sys.stdin. To specify an alternative list of
-filenames, pass it as the argument to input(). A single file name is
-also allowed.
-
-Functions filename(), lineno() return the filename and cumulative line
-number of the line that has just been read; filelineno() returns its
-line number in the current file; isfirstline() returns true iff the
-line just read is the first line of its file; isstdin() returns true
-iff the line was read from sys.stdin. Function nextfile() closes the
-current file so that the next iteration will read the first line from
-the next file (if any); lines not read from the file will not count
-towards the cumulative line count; the filename is not changed until
-after the first line of the next file has been read. Function close()
-closes the sequence.
-
-Before any lines have been read, filename() returns None and both line
-numbers are zero; nextfile() has no effect. After all lines have been
-read, filename() and the line number functions return the values
-pertaining to the last line read; nextfile() has no effect.
-
-All files are opened in text mode. If an I/O error occurs during
-opening or reading a file, the IOError exception is raised.
-
-If sys.stdin is used more than once, the second and further use will
-return no lines, except perhaps for interactive use, or if it has been
-explicitly reset (e.g. using sys.stdin.seek(0)).
-
-Empty files are opened and immediately closed; the only time their
-presence in the list of filenames is noticeable at all is when the
-last file opened is empty.
-
-It is possible that the last line of a file doesn't end in a newline
-character; otherwise lines are returned including the trailing
-newline.
-
-Class FileInput is the implementation; its methods filename(),
-lineno(), fileline(), isfirstline(), isstdin(), nextfile() and close()
-correspond to the functions in the module. In addition it has a
-readline() method which returns the next input line, and a
-__getitem__() method which implements the sequence behavior. The
-sequence must be accessed in strictly sequential order; sequence
-access and readline() cannot be mixed.
-
-Optional in-place filtering: if the keyword argument inplace=1 is
-passed to input() or to the FileInput constructor, the file is moved
-to a backup file and standard output is directed to the input file.
-This makes it possible to write a filter that rewrites its input file
-in place. If the keyword argument backup=".<some extension>" is also
-given, it specifies the extension for the backup file, and the backup
-file remains around; by default, the extension is ".bak" and it is
-deleted when the output file is closed. In-place filtering is
-disabled when standard input is read. XXX The current implementation
-does not work for MS-DOS 8+3 filesystems.
-
-XXX Possible additions:
-
-- optional getopt argument processing
-- specify open mode ('r' or 'rb')
-- specify buffer size
-- fileno()
-- isatty()
-- read(), read(size), even readlines()
-
-"""
-
-import sys, os, stat
-
-_state = None
-
-def input(files=None, inplace=0, backup=""):
- global _state
- if _state and _state._file:
- raise RuntimeError, "input() already active"
- _state = FileInput(files, inplace, backup)
- return _state
-
-def close():
- global _state
- state = _state
- _state = None
- if state:
- state.close()
-
-def nextfile():
- if not _state:
- raise RuntimeError, "no active input()"
- return _state.nextfile()
-
-def filename():
- if not _state:
- raise RuntimeError, "no active input()"
- return _state.filename()
-
-def lineno():
- if not _state:
- raise RuntimeError, "no active input()"
- return _state.lineno()
-
-def filelineno():
- if not _state:
- raise RuntimeError, "no active input()"
- return _state.filelineno()
-
-def isfirstline():
- if not _state:
- raise RuntimeError, "no active input()"
- return _state.isfirstline()
-
-def isstdin():
- if not _state:
- raise RuntimeError, "no active input()"
- return _state.isstdin()
-
-class FileInput:
-
- def __init__(self, files=None, inplace=0, backup=""):
- if type(files) == type(''):
- files = (files,)
- else:
- if files is None:
- files = sys.argv[1:]
- if not files:
- files = ('-',)
- else:
- files = tuple(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
- self._backupfilename = None
-
- def __del__(self):
- self.close()
-
- def close(self):
- 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
-
- def nextfile(self):
- savestdout = self._savestdout
- self._savestdout = 0
- if savestdout:
- sys.stdout = savestdout
-
- output = self._output
- self._output = 0
- if output:
- output.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
-
- self._isstdin = 0
-
- def readline(self):
- if not self._file:
- if not self._files:
- return ""
- self._filename = self._files[0]
- self._files = self._files[1:]
- self._filelineno = 0
- self._file = None
- self._isstdin = 0
- self._backupfilename = 0
- if self._filename == '-':
- self._filename = '<stdin>'
- self._file = sys.stdin
- self._isstdin = 1
- else:
- if self._inplace:
- self._backupfilename = (
- self._filename + (self._backup or ".bak"))
- try: os.unlink(self._backupfilename)
- except os.error: pass
- # The next few lines may raise IOError
- os.rename(self._filename, self._backupfilename)
- self._file = open(self._backupfilename, "r")
- try:
- perm = os.fstat(self._file.fileno())[stat.ST_MODE]
- except:
- self._output = open(self._filename, "w")
- else:
- fd = os.open(self._filename,
- os.O_CREAT | os.O_WRONLY | os.O_TRUNC,
- perm)
- self._output = os.fdopen(fd, "w")
- try:
- os.chmod(self._filename, perm)
- except:
- pass
- 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
-
- def lineno(self):
- return self._lineno
-
- def filelineno(self):
- return self._filelineno
-
- def isfirstline(self):
- return self._filelineno == 1
-
- def isstdin(self):
- return self._isstdin
-
-def _test():
- import getopt
- inplace = 0
- 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
- 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)
- print "%d: %s[%d]" % (lineno(), filename(), filelineno())
-
-if __name__ == '__main__':
- _test()
diff --git a/Lib/dos-8x3/formatte.py b/Lib/dos-8x3/formatte.py
deleted file mode 100755
index 4d6a129..0000000
--- a/Lib/dos-8x3/formatte.py
+++ /dev/null
@@ -1,422 +0,0 @@
-"""Generic output formatting.
-
-Formatter objects transform an abstract flow of formatting events into
-specific output events on writer objects. Formatters manage several stack
-structures to allow various properties of a writer object to be changed and
-restored; writers need not be able to handle relative changes nor any sort
-of ``change back'' operation. Specific writer properties which may be
-controlled via formatter objects are horizontal alignment, font, and left
-margin indentations. A mechanism is provided which supports providing
-arbitrary, non-exclusive style settings to a writer as well. Additional
-interfaces facilitate formatting events which are not reversible, such as
-paragraph separation.
-
-Writer objects encapsulate device interfaces. Abstract devices, such as
-file formats, are supported as well as physical devices. The provided
-implementations all work with abstract devices. The interface makes
-available mechanisms for setting the properties which formatter objects
-manage and inserting data into the output.
-"""
-
-import string
-import sys
-from types import StringType
-
-
-AS_IS = None
-
-
-class NullFormatter:
-
- def __init__(self, writer=None):
- 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
- def add_label_data(self, format, counter, blankline=None): pass
- def add_flowing_data(self, data): pass
- def add_literal_data(self, data): pass
- def flush_softspace(self): pass
- def push_alignment(self, align): pass
- def pop_alignment(self): pass
- def push_font(self, x): pass
- def pop_font(self): pass
- def push_margin(self, margin): pass
- def pop_margin(self): pass
- def set_spacing(self, spacing): pass
- def push_style(self, *styles): pass
- def pop_style(self, n=1): pass
- def assert_line_data(self, flag=1): pass
-
-
-class AbstractFormatter:
-
- # Space handling policy: blank spaces at the boundary between elements
- # are handled by the outermost context. "Literal" data is not checked
- # to determine context, so spaces in literal data are handled directly
- # 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
-
- def end_paragraph(self, blankline):
- if not self.hard_break:
- self.writer.send_line_break()
- self.have_label = 0
- if self.parskip < blankline and not self.have_label:
- self.writer.send_paragraph(blankline - self.parskip)
- self.parskip = blankline
- self.have_label = 0
- self.hard_break = self.nospace = self.para_end = 1
- self.softspace = 0
-
- def add_line_break(self):
- if not (self.hard_break or self.para_end):
- self.writer.send_line_break()
- self.have_label = self.parskip = 0
- self.hard_break = self.nospace = 1
- self.softspace = 0
-
- def add_hor_rule(self, *args, **kw):
- if not self.hard_break:
- self.writer.send_line_break()
- apply(self.writer.send_hor_rule, args, kw)
- self.hard_break = self.nospace = 1
- self.have_label = self.para_end = self.softspace = self.parskip = 0
-
- def add_label_data(self, format, counter, blankline = None):
- if self.have_label or not self.hard_break:
- self.writer.send_line_break()
- if not self.para_end:
- self.writer.send_paragraph((blankline and 1) or 0)
- if type(format) is StringType:
- self.writer.send_label_data(self.format_counter(format, counter))
- else:
- self.writer.send_label_data(format)
- self.nospace = self.have_label = self.hard_break = self.para_end = 1
- self.softspace = self.parskip = 0
-
- def format_counter(self, format, counter):
- label = ''
- for c in format:
- try:
- if c == '1':
- label = label + ('%d' % counter)
- elif c in 'aA':
- if counter > 0:
- label = label + self.format_letter(c, counter)
- elif c in 'iI':
- if counter > 0:
- label = label + self.format_roman(c, counter)
- else:
- label = label + c
- except:
- label = label + c
- return label
-
- def format_letter(self, case, counter):
- label = ''
- while counter > 0:
- counter, x = divmod(counter-1, 26)
- s = chr(ord(case) + x)
- label = s + label
- return label
-
- def format_roman(self, case, counter):
- ones = ['i', 'x', 'c', 'm']
- fives = ['v', 'l', 'd']
- label, index = '', 0
- # This will die of IndexError when counter is too big
- while counter > 0:
- counter, x = divmod(counter, 10)
- if x == 9:
- label = ones[index] + ones[index+1] + label
- elif x == 4:
- label = ones[index] + fives[index] + label
- else:
- if x >= 5:
- s = fives[index]
- x = x-5
- else:
- s = ''
- s = s + ones[index]*x
- label = s + label
- index = index + 1
- if case == 'I':
- return string.upper(label)
- return label
-
- def add_flowing_data(self, data,
- # These are only here to load them into locals:
- whitespace = string.whitespace,
- join = string.join, split = string.split):
- if not data: return
- # The following looks a bit convoluted but is a great improvement over
- # data = regsub.gsub('[' + string.whitespace + ']+', ' ', data)
- prespace = data[:1] in whitespace
- postspace = data[-1:] in whitespace
- data = join(split(data))
- if self.nospace and not data:
- return
- elif prespace or self.softspace:
- if not data:
- if not self.nospace:
- self.softspace = 1
- self.parskip = 0
- return
- if not self.nospace:
- data = ' ' + data
- self.hard_break = self.nospace = self.para_end = \
- self.parskip = self.have_label = 0
- self.softspace = postspace
- self.writer.send_flowing_data(data)
-
- def add_literal_data(self, data):
- if not data: return
- 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(' ')
-
- def push_alignment(self, align):
- if align and align != self.align:
- self.writer.new_alignment(align)
- self.align = align
- self.align_stack.append(align)
- else:
- self.align_stack.append(self.align)
-
- def pop_alignment(self):
- if self.align_stack:
- del self.align_stack[-1]
- if self.align_stack:
- self.align = align = self.align_stack[-1]
- self.writer.new_alignment(align)
- else:
- self.align = None
- self.writer.new_alignment(None)
-
- def push_font(self, (size, i, b, tt)):
- if self.softspace:
- self.hard_break = self.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)
-
- def push_margin(self, margin):
- self.margin_stack.append(margin)
- fstack = filter(None, self.margin_stack)
- if not margin and fstack:
- margin = fstack[-1]
- self.writer.new_margin(margin, len(fstack))
-
- def pop_margin(self):
- if self.margin_stack:
- del self.margin_stack[-1]
- fstack = filter(None, self.margin_stack)
- if fstack:
- margin = fstack[-1]
- else:
- margin = None
- self.writer.new_margin(margin, len(fstack))
-
- def set_spacing(self, spacing):
- self.spacing = spacing
- self.writer.new_spacing(spacing)
-
- def push_style(self, *styles):
- if self.softspace:
- self.hard_break = self.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))
-
- def assert_line_data(self, flag=1):
- self.nospace = self.hard_break = not flag
- self.para_end = self.parskip = self.have_label = 0
-
-
-class NullWriter:
- """Minimal writer interface to use in testing & inheritance."""
- def __init__(self): pass
- def flush(self): pass
- def new_alignment(self, align): pass
- def new_font(self, font): pass
- def new_margin(self, margin, level): pass
- def new_spacing(self, spacing): pass
- def new_styles(self, styles): pass
- def send_paragraph(self, blankline): pass
- def send_line_break(self): pass
- def send_hor_rule(self, *args, **kw): pass
- def send_label_data(self, data): pass
- def send_flowing_data(self, data): pass
- def send_literal_data(self, data): pass
-
-
-class AbstractWriter(NullWriter):
-
- def __init__(self):
- pass
-
- def new_alignment(self, align):
- print "new_alignment(%s)" % `align`
-
- def new_font(self, font):
- print "new_font(%s)" % `font`
-
- def new_margin(self, margin, level):
- print "new_margin(%s, %d)" % (`margin`, level)
-
- def new_spacing(self, spacing):
- print "new_spacing(%s)" % `spacing`
-
- def new_styles(self, styles):
- print "new_styles(%s)" % `styles`
-
- def send_paragraph(self, blankline):
- print "send_paragraph(%s)" % `blankline`
-
- def send_line_break(self):
- print "send_line_break()"
-
- def send_hor_rule(self, *args, **kw):
- print "send_hor_rule()"
-
- def send_label_data(self, data):
- print "send_label_data(%s)" % `data`
-
- def send_flowing_data(self, data):
- print "send_flowing_data(%s)" % `data`
-
- def send_literal_data(self, data):
- print "send_literal_data(%s)" % `data`
-
-
-class DumbWriter(NullWriter):
-
- def __init__(self, file=None, maxcol=72):
- self.file = file or sys.stdout
- self.maxcol = maxcol
- NullWriter.__init__(self)
- self.reset()
-
- def reset(self):
- self.col = 0
- self.atbreak = 0
-
- def send_paragraph(self, blankline):
- self.file.write('\n'*blankline)
- self.col = 0
- self.atbreak = 0
-
- def send_line_break(self):
- self.file.write('\n')
- self.col = 0
- self.atbreak = 0
-
- def send_hor_rule(self, *args, **kw):
- self.file.write('\n')
- self.file.write('-'*self.maxcol)
- self.file.write('\n')
- self.col = 0
- self.atbreak = 0
-
- def send_literal_data(self, data):
- self.file.write(data)
- i = string.rfind(data, '\n')
- if i >= 0:
- self.col = 0
- data = data[i+1:]
- data = string.expandtabs(data)
- self.col = self.col + len(data)
- self.atbreak = 0
-
- def send_flowing_data(self, data):
- if not data: return
- atbreak = self.atbreak or data[0] in string.whitespace
- col = self.col
- maxcol = self.maxcol
- write = self.file.write
- for word in string.split(data):
- if atbreak:
- if col + len(word) >= maxcol:
- write('\n')
- col = 0
- else:
- write(' ')
- col = col + 1
- write(word)
- col = col + len(word)
- atbreak = 1
- self.col = col
- self.atbreak = data[-1] in string.whitespace
-
-
-def test(file = None):
- w = DumbWriter()
- f = AbstractFormatter(w)
- if file:
- fp = open(file)
- elif sys.argv[1:]:
- fp = open(sys.argv[1])
- else:
- fp = sys.stdin
- while 1:
- line = fp.readline()
- if not line:
- break
- if line == '\n':
- f.end_paragraph(1)
- else:
- f.add_flowing_data(line)
- f.end_paragraph(0)
-
-
-if __name__ == '__main__':
- test()
diff --git a/Lib/dos-8x3/gopherli.py b/Lib/dos-8x3/gopherli.py
deleted file mode 100755
index 6965fbd..0000000
--- a/Lib/dos-8x3/gopherli.py
+++ /dev/null
@@ -1,208 +0,0 @@
-"""Gopher protocol client interface."""
-
-import string
-
-# Default selector, host and port
-DEF_SELECTOR = '1/'
-DEF_HOST = 'gopher.micro.umn.edu'
-DEF_PORT = 70
-
-# Recognized file types
-A_TEXT = '0'
-A_MENU = '1'
-A_CSO = '2'
-A_ERROR = '3'
-A_MACBINHEX = '4'
-A_PCBINHEX = '5'
-A_UUENCODED = '6'
-A_INDEX = '7'
-A_TELNET = '8'
-A_BINARY = '9'
-A_DUPLICATE = '+'
-A_SOUND = 's'
-A_EVENT = 'e'
-A_CALENDAR = 'c'
-A_HTML = 'h'
-A_TN3270 = 'T'
-A_MIME = 'M'
-A_IMAGE = 'I'
-A_WHOIS = 'w'
-A_QUERY = 'q'
-A_GIF = 'g'
-A_HTML = 'h' # HTML file
-A_WWW = 'w' # WWW address
-A_PLUS_IMAGE = ':'
-A_PLUS_MOVIE = ';'
-A_PLUS_SOUND = '<'
-
-
-_names = dir()
-_type_to_name_map = {}
-def type_to_name(gtype):
- """Map all file types to strings; unknown types become TYPE='x'."""
- global _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:]
- if _type_to_name_map.has_key(gtype):
- return _type_to_name_map[gtype]
- return 'TYPE=' + `gtype`
-
-# Names for characters and strings
-CRLF = '\r\n'
-TAB = '\t'
-
-def send_selector(selector, host, port = 0):
- """Send a selector to a given host and port, return a file with the reply."""
- import socket
- import string
- if not port:
- i = string.find(host, ':')
- if i >= 0:
- host, port = host[:i], string.atoi(host[i+1:])
- if not port:
- port = DEF_PORT
- elif type(port) == type(''):
- port = string.atoi(port)
- s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- s.connect((host, port))
- s.send(selector + CRLF)
- s.shutdown(1)
- return s.makefile('rb')
-
-def send_query(selector, query, host, port = 0):
- """Send a selector and a query string."""
- return send_selector(selector + '\t' + query, host, port)
-
-def path_to_selector(path):
- """Takes a path as returned by urlparse and returns the appropriate selector."""
- if path=="/":
- return "/"
- else:
- return path[2:] # Cuts initial slash and data type identifier
-
-def path_to_datatype_name(path):
- """Takes a path as returned by urlparse and maps it to a string.
- See section 3.4 of RFC 1738 for details."""
- 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
-
-def get_directory(f):
- """Get a directory in the form of a list of entries."""
- import string
- list = []
- while 1:
- line = f.readline()
- if not line:
- print '(Unexpected EOF from server)'
- break
- if line[-2:] == CRLF:
- line = line[:-2]
- elif line[-1:] in CRLF:
- line = line[:-1]
- if line == '.':
- break
- if not line:
- print '(Empty line from server)'
- continue
- gtype = line[0]
- parts = string.splitfields(line[1:], TAB)
- if len(parts) < 4:
- print '(Bad line from server:', `line`, ')'
- continue
- if len(parts) > 4:
- if parts[4:] != ['+']:
- print '(Extra info from server:',
- print parts[4:], ')'
- else:
- parts.append('')
- parts.insert(0, gtype)
- list.append(parts)
- return list
-
-def get_textfile(f):
- """Get a text file as a list of lines, with trailing CRLF stripped."""
- list = []
- get_alt_textfile(f, list.append)
- return list
-
-def get_alt_textfile(f, func):
- """Get a text file and pass each line to a function, with trailing CRLF stripped."""
- while 1:
- line = f.readline()
- if not line:
- print '(Unexpected EOF from server)'
- break
- if line[-2:] == CRLF:
- line = line[:-2]
- elif line[-1:] in CRLF:
- line = line[:-1]
- if line == '.':
- break
- if line[:2] == '..':
- line = line[1:]
- func(line)
-
-def get_binary(f):
- """Get a binary file as one solid data block."""
- data = f.read()
- return data
-
-def get_alt_binary(f, func, blocksize):
- """Get a binary file and pass each block to a function."""
- while 1:
- data = f.read(blocksize)
- if not data:
- break
- func(data)
-
-def test():
- """Trivial test program."""
- import sys
- import getopt
- opts, args = getopt.getopt(sys.argv[1:], '')
- selector = DEF_SELECTOR
- type = selector[0]
- host = DEF_HOST
- port = DEF_PORT
- if args:
- host = args[0]
- args = args[1:]
- if args:
- type = args[0]
- args = args[1:]
- if len(type) > 1:
- type, selector = type[0], type
- else:
- selector = ''
- if args:
- selector = args[0]
- args = args[1:]
- query = ''
- if args:
- query = args[0]
- args = args[1:]
- if type == A_INDEX:
- f = send_query(selector, query, host)
- else:
- f = send_selector(selector, host)
- if type == A_TEXT:
- list = get_textfile(f)
- for item in list: print item
- elif type in (A_MENU, A_INDEX):
- list = get_directory(f)
- for item in list: print item
- else:
- data = get_binary(f)
- print 'binary data:', len(data), 'bytes:', `data[:100]`[:40]
-
-# Run the test when run as script
-if __name__ == '__main__':
- test()
diff --git a/Lib/dos-8x3/htmlenti.py b/Lib/dos-8x3/htmlenti.py
deleted file mode 100755
index 6682bf2..0000000
--- a/Lib/dos-8x3/htmlenti.py
+++ /dev/null
@@ -1,257 +0,0 @@
-"""HTML character entity references."""
-
-entitydefs = {
- 'AElig': '\306', # latin capital letter AE = latin capital ligature AE, U+00C6 ISOlat1
- 'Aacute': '\301', # latin capital letter A with acute, U+00C1 ISOlat1
- 'Acirc': '\302', # latin capital letter A with circumflex, U+00C2 ISOlat1
- 'Agrave': '\300', # latin capital letter A with grave = latin capital letter A grave, U+00C0 ISOlat1
- 'Alpha': 'Α', # greek capital letter alpha, U+0391
- 'Aring': '\305', # latin capital letter A with ring above = latin capital letter A ring, U+00C5 ISOlat1
- 'Atilde': '\303', # latin capital letter A with tilde, U+00C3 ISOlat1
- 'Auml': '\304', # latin capital letter A with diaeresis, U+00C4 ISOlat1
- 'Beta': 'Β', # greek capital letter beta, U+0392
- 'Ccedil': '\307', # latin capital letter C with cedilla, U+00C7 ISOlat1
- 'Chi': 'Χ', # greek capital letter chi, U+03A7
- 'Dagger': '‡', # double dagger, U+2021 ISOpub
- 'Delta': 'Δ', # greek capital letter delta, U+0394 ISOgrk3
- 'ETH': '\320', # latin capital letter ETH, U+00D0 ISOlat1
- 'Eacute': '\311', # latin capital letter E with acute, U+00C9 ISOlat1
- 'Ecirc': '\312', # latin capital letter E with circumflex, U+00CA ISOlat1
- 'Egrave': '\310', # latin capital letter E with grave, U+00C8 ISOlat1
- 'Epsilon': 'Ε', # greek capital letter epsilon, U+0395
- 'Eta': 'Η', # greek capital letter eta, U+0397
- 'Euml': '\313', # latin capital letter E with diaeresis, U+00CB ISOlat1
- 'Gamma': 'Γ', # greek capital letter gamma, U+0393 ISOgrk3
- 'Iacute': '\315', # latin capital letter I with acute, U+00CD ISOlat1
- 'Icirc': '\316', # latin capital letter I with circumflex, U+00CE ISOlat1
- 'Igrave': '\314', # latin capital letter I with grave, U+00CC ISOlat1
- 'Iota': 'Ι', # greek capital letter iota, U+0399
- 'Iuml': '\317', # latin capital letter I with diaeresis, U+00CF ISOlat1
- 'Kappa': 'Κ', # greek capital letter kappa, U+039A
- 'Lambda': 'Λ', # greek capital letter lambda, U+039B ISOgrk3
- 'Mu': 'Μ', # greek capital letter mu, U+039C
- 'Ntilde': '\321', # latin capital letter N with tilde, U+00D1 ISOlat1
- 'Nu': 'Ν', # greek capital letter nu, U+039D
- 'OElig': 'Œ', # latin capital ligature OE, U+0152 ISOlat2
- 'Oacute': '\323', # latin capital letter O with acute, U+00D3 ISOlat1
- 'Ocirc': '\324', # latin capital letter O with circumflex, U+00D4 ISOlat1
- 'Ograve': '\322', # latin capital letter O with grave, U+00D2 ISOlat1
- 'Omega': 'Ω', # greek capital letter omega, U+03A9 ISOgrk3
- 'Omicron': 'Ο', # greek capital letter omicron, U+039F
- 'Oslash': '\330', # latin capital letter O with stroke = latin capital letter O slash, U+00D8 ISOlat1
- 'Otilde': '\325', # latin capital letter O with tilde, U+00D5 ISOlat1
- 'Ouml': '\326', # latin capital letter O with diaeresis, U+00D6 ISOlat1
- 'Phi': 'Φ', # greek capital letter phi, U+03A6 ISOgrk3
- 'Pi': 'Π', # greek capital letter pi, U+03A0 ISOgrk3
- 'Prime': '″', # double prime = seconds = inches, U+2033 ISOtech
- 'Psi': 'Ψ', # greek capital letter psi, U+03A8 ISOgrk3
- 'Rho': 'Ρ', # greek capital letter rho, U+03A1
- 'Scaron': 'Š', # latin capital letter S with caron, U+0160 ISOlat2
- 'Sigma': 'Σ', # greek capital letter sigma, U+03A3 ISOgrk3
- 'THORN': '\336', # latin capital letter THORN, U+00DE ISOlat1
- 'Tau': 'Τ', # greek capital letter tau, U+03A4
- 'Theta': 'Θ', # greek capital letter theta, U+0398 ISOgrk3
- 'Uacute': '\332', # latin capital letter U with acute, U+00DA ISOlat1
- 'Ucirc': '\333', # latin capital letter U with circumflex, U+00DB ISOlat1
- 'Ugrave': '\331', # latin capital letter U with grave, U+00D9 ISOlat1
- 'Upsilon': 'Υ', # greek capital letter upsilon, U+03A5 ISOgrk3
- 'Uuml': '\334', # latin capital letter U with diaeresis, U+00DC ISOlat1
- 'Xi': 'Ξ', # greek capital letter xi, U+039E ISOgrk3
- 'Yacute': '\335', # latin capital letter Y with acute, U+00DD ISOlat1
- 'Yuml': 'Ÿ', # latin capital letter Y with diaeresis, U+0178 ISOlat2
- 'Zeta': 'Ζ', # greek capital letter zeta, U+0396
- 'aacute': '\341', # latin small letter a with acute, U+00E1 ISOlat1
- 'acirc': '\342', # latin small letter a with circumflex, U+00E2 ISOlat1
- 'acute': '\264', # acute accent = spacing acute, U+00B4 ISOdia
- 'aelig': '\346', # latin small letter ae = latin small ligature ae, U+00E6 ISOlat1
- 'agrave': '\340', # latin small letter a with grave = latin small letter a grave, U+00E0 ISOlat1
- 'alefsym': 'ℵ', # alef symbol = first transfinite cardinal, U+2135 NEW
- 'alpha': 'α', # greek small letter alpha, U+03B1 ISOgrk3
- 'amp': '\46', # ampersand, U+0026 ISOnum
- 'and': '∧', # logical and = wedge, U+2227 ISOtech
- 'ang': '∠', # angle, U+2220 ISOamso
- 'aring': '\345', # latin small letter a with ring above = latin small letter a ring, U+00E5 ISOlat1
- 'asymp': '≈', # almost equal to = asymptotic to, U+2248 ISOamsr
- 'atilde': '\343', # latin small letter a with tilde, U+00E3 ISOlat1
- 'auml': '\344', # latin small letter a with diaeresis, U+00E4 ISOlat1
- 'bdquo': '„', # double low-9 quotation mark, U+201E NEW
- 'beta': 'β', # greek small letter beta, U+03B2 ISOgrk3
- 'brvbar': '\246', # broken bar = broken vertical bar, U+00A6 ISOnum
- 'bull': '•', # bullet = black small circle, U+2022 ISOpub
- 'cap': '∩', # intersection = cap, U+2229 ISOtech
- 'ccedil': '\347', # latin small letter c with cedilla, U+00E7 ISOlat1
- 'cedil': '\270', # cedilla = spacing cedilla, U+00B8 ISOdia
- 'cent': '\242', # cent sign, U+00A2 ISOnum
- 'chi': 'χ', # greek small letter chi, U+03C7 ISOgrk3
- 'circ': 'ˆ', # modifier letter circumflex accent, U+02C6 ISOpub
- 'clubs': '♣', # black club suit = shamrock, U+2663 ISOpub
- 'cong': '≅', # approximately equal to, U+2245 ISOtech
- 'copy': '\251', # copyright sign, U+00A9 ISOnum
- 'crarr': '↵', # downwards arrow with corner leftwards = carriage return, U+21B5 NEW
- 'cup': '∪', # union = cup, U+222A ISOtech
- 'curren': '\244', # currency sign, U+00A4 ISOnum
- 'dArr': '⇓', # downwards double arrow, U+21D3 ISOamsa
- 'dagger': '†', # dagger, U+2020 ISOpub
- 'darr': '↓', # downwards arrow, U+2193 ISOnum
- 'deg': '\260', # degree sign, U+00B0 ISOnum
- 'delta': 'δ', # greek small letter delta, U+03B4 ISOgrk3
- 'diams': '♦', # black diamond suit, U+2666 ISOpub
- 'divide': '\367', # division sign, U+00F7 ISOnum
- 'eacute': '\351', # latin small letter e with acute, U+00E9 ISOlat1
- 'ecirc': '\352', # latin small letter e with circumflex, U+00EA ISOlat1
- 'egrave': '\350', # latin small letter e with grave, U+00E8 ISOlat1
- 'empty': '∅', # empty set = null set = diameter, U+2205 ISOamso
- 'emsp': ' ', # em space, U+2003 ISOpub
- 'ensp': ' ', # en space, U+2002 ISOpub
- 'epsilon': 'ε', # greek small letter epsilon, U+03B5 ISOgrk3
- 'equiv': '≡', # identical to, U+2261 ISOtech
- 'eta': 'η', # greek small letter eta, U+03B7 ISOgrk3
- 'eth': '\360', # latin small letter eth, U+00F0 ISOlat1
- 'euml': '\353', # latin small letter e with diaeresis, U+00EB ISOlat1
- 'euro': '€', # euro sign, U+20AC NEW
- 'exist': '∃', # there exists, U+2203 ISOtech
- 'fnof': 'ƒ', # latin small f with hook = function = florin, U+0192 ISOtech
- 'forall': '∀', # for all, U+2200 ISOtech
- 'frac12': '\275', # vulgar fraction one half = fraction one half, U+00BD ISOnum
- 'frac14': '\274', # vulgar fraction one quarter = fraction one quarter, U+00BC ISOnum
- 'frac34': '\276', # vulgar fraction three quarters = fraction three quarters, U+00BE ISOnum
- 'frasl': '⁄', # fraction slash, U+2044 NEW
- 'gamma': 'γ', # greek small letter gamma, U+03B3 ISOgrk3
- 'ge': '≥', # greater-than or equal to, U+2265 ISOtech
- 'gt': '\76', # greater-than sign, U+003E ISOnum
- 'hArr': '⇔', # left right double arrow, U+21D4 ISOamsa
- 'harr': '↔', # left right arrow, U+2194 ISOamsa
- 'hearts': '♥', # black heart suit = valentine, U+2665 ISOpub
- 'hellip': '…', # horizontal ellipsis = three dot leader, U+2026 ISOpub
- 'iacute': '\355', # latin small letter i with acute, U+00ED ISOlat1
- 'icirc': '\356', # latin small letter i with circumflex, U+00EE ISOlat1
- 'iexcl': '\241', # inverted exclamation mark, U+00A1 ISOnum
- 'igrave': '\354', # latin small letter i with grave, U+00EC ISOlat1
- 'image': 'ℑ', # blackletter capital I = imaginary part, U+2111 ISOamso
- 'infin': '∞', # infinity, U+221E ISOtech
- 'int': '∫', # integral, U+222B ISOtech
- 'iota': 'ι', # greek small letter iota, U+03B9 ISOgrk3
- 'iquest': '\277', # inverted question mark = turned question mark, U+00BF ISOnum
- 'isin': '∈', # element of, U+2208 ISOtech
- 'iuml': '\357', # latin small letter i with diaeresis, U+00EF ISOlat1
- 'kappa': 'κ', # greek small letter kappa, U+03BA ISOgrk3
- 'lArr': '⇐', # leftwards double arrow, U+21D0 ISOtech
- 'lambda': 'λ', # greek small letter lambda, U+03BB ISOgrk3
- 'lang': '〈', # left-pointing angle bracket = bra, U+2329 ISOtech
- 'laquo': '\253', # left-pointing double angle quotation mark = left pointing guillemet, U+00AB ISOnum
- 'larr': '←', # leftwards arrow, U+2190 ISOnum
- 'lceil': '⌈', # left ceiling = apl upstile, U+2308 ISOamsc
- 'ldquo': '“', # left double quotation mark, U+201C ISOnum
- 'le': '≤', # less-than or equal to, U+2264 ISOtech
- 'lfloor': '⌊', # left floor = apl downstile, U+230A ISOamsc
- 'lowast': '∗', # asterisk operator, U+2217 ISOtech
- 'loz': '◊', # lozenge, U+25CA ISOpub
- 'lrm': '‎', # left-to-right mark, U+200E NEW RFC 2070
- 'lsaquo': '‹', # single left-pointing angle quotation mark, U+2039 ISO proposed
- 'lsquo': '‘', # left single quotation mark, U+2018 ISOnum
- 'lt': '\74', # less-than sign, U+003C ISOnum
- 'macr': '\257', # macron = spacing macron = overline = APL overbar, U+00AF ISOdia
- 'mdash': '—', # em dash, U+2014 ISOpub
- 'micro': '\265', # micro sign, U+00B5 ISOnum
- 'middot': '\267', # middle dot = Georgian comma = Greek middle dot, U+00B7 ISOnum
- 'minus': '−', # minus sign, U+2212 ISOtech
- 'mu': 'μ', # greek small letter mu, U+03BC ISOgrk3
- 'nabla': '∇', # nabla = backward difference, U+2207 ISOtech
- 'nbsp': '\240', # no-break space = non-breaking space, U+00A0 ISOnum
- 'ndash': '–', # en dash, U+2013 ISOpub
- 'ne': '≠', # not equal to, U+2260 ISOtech
- 'ni': '∋', # contains as member, U+220B ISOtech
- 'not': '\254', # not sign, U+00AC ISOnum
- 'notin': '∉', # not an element of, U+2209 ISOtech
- 'nsub': '⊄', # not a subset of, U+2284 ISOamsn
- 'ntilde': '\361', # latin small letter n with tilde, U+00F1 ISOlat1
- 'nu': 'ν', # greek small letter nu, U+03BD ISOgrk3
- 'oacute': '\363', # latin small letter o with acute, U+00F3 ISOlat1
- 'ocirc': '\364', # latin small letter o with circumflex, U+00F4 ISOlat1
- 'oelig': 'œ', # latin small ligature oe, U+0153 ISOlat2
- 'ograve': '\362', # latin small letter o with grave, U+00F2 ISOlat1
- 'oline': '‾', # overline = spacing overscore, U+203E NEW
- 'omega': 'ω', # greek small letter omega, U+03C9 ISOgrk3
- 'omicron': 'ο', # greek small letter omicron, U+03BF NEW
- 'oplus': '⊕', # circled plus = direct sum, U+2295 ISOamsb
- 'or': '∨', # logical or = vee, U+2228 ISOtech
- 'ordf': '\252', # feminine ordinal indicator, U+00AA ISOnum
- 'ordm': '\272', # masculine ordinal indicator, U+00BA ISOnum
- 'oslash': '\370', # latin small letter o with stroke, = latin small letter o slash, U+00F8 ISOlat1
- 'otilde': '\365', # latin small letter o with tilde, U+00F5 ISOlat1
- 'otimes': '⊗', # circled times = vector product, U+2297 ISOamsb
- 'ouml': '\366', # latin small letter o with diaeresis, U+00F6 ISOlat1
- 'para': '\266', # pilcrow sign = paragraph sign, U+00B6 ISOnum
- 'part': '∂', # partial differential, U+2202 ISOtech
- 'permil': '‰', # per mille sign, U+2030 ISOtech
- 'perp': '⊥', # up tack = orthogonal to = perpendicular, U+22A5 ISOtech
- 'phi': 'φ', # greek small letter phi, U+03C6 ISOgrk3
- 'pi': 'π', # greek small letter pi, U+03C0 ISOgrk3
- 'piv': 'ϖ', # greek pi symbol, U+03D6 ISOgrk3
- 'plusmn': '\261', # plus-minus sign = plus-or-minus sign, U+00B1 ISOnum
- 'pound': '\243', # pound sign, U+00A3 ISOnum
- 'prime': '′', # prime = minutes = feet, U+2032 ISOtech
- 'prod': '∏', # n-ary product = product sign, U+220F ISOamsb
- 'prop': '∝', # proportional to, U+221D ISOtech
- 'psi': 'ψ', # greek small letter psi, U+03C8 ISOgrk3
- 'quot': '\42', # quotation mark = APL quote, U+0022 ISOnum
- 'rArr': '⇒', # rightwards double arrow, U+21D2 ISOtech
- 'radic': '√', # square root = radical sign, U+221A ISOtech
- 'rang': '〉', # right-pointing angle bracket = ket, U+232A ISOtech
- 'raquo': '\273', # right-pointing double angle quotation mark = right pointing guillemet, U+00BB ISOnum
- 'rarr': '→', # rightwards arrow, U+2192 ISOnum
- 'rceil': '⌉', # right ceiling, U+2309 ISOamsc
- 'rdquo': '”', # right double quotation mark, U+201D ISOnum
- 'real': 'ℜ', # blackletter capital R = real part symbol, U+211C ISOamso
- 'reg': '\256', # registered sign = registered trade mark sign, U+00AE ISOnum
- 'rfloor': '⌋', # right floor, U+230B ISOamsc
- 'rho': 'ρ', # greek small letter rho, U+03C1 ISOgrk3
- 'rlm': '‏', # right-to-left mark, U+200F NEW RFC 2070
- 'rsaquo': '›', # single right-pointing angle quotation mark, U+203A ISO proposed
- 'rsquo': '’', # right single quotation mark, U+2019 ISOnum
- 'sbquo': '‚', # single low-9 quotation mark, U+201A NEW
- 'scaron': 'š', # latin small letter s with caron, U+0161 ISOlat2
- 'sdot': '⋅', # dot operator, U+22C5 ISOamsb
- 'sect': '\247', # section sign, U+00A7 ISOnum
- 'shy': '\255', # soft hyphen = discretionary hyphen, U+00AD ISOnum
- 'sigma': 'σ', # greek small letter sigma, U+03C3 ISOgrk3
- 'sigmaf': 'ς', # greek small letter final sigma, U+03C2 ISOgrk3
- 'sim': '∼', # tilde operator = varies with = similar to, U+223C ISOtech
- 'spades': '♠', # black spade suit, U+2660 ISOpub
- 'sub': '⊂', # subset of, U+2282 ISOtech
- 'sube': '⊆', # subset of or equal to, U+2286 ISOtech
- 'sum': '∑', # n-ary sumation, U+2211 ISOamsb
- 'sup': '⊃', # superset of, U+2283 ISOtech
- 'sup1': '\271', # superscript one = superscript digit one, U+00B9 ISOnum
- 'sup2': '\262', # superscript two = superscript digit two = squared, U+00B2 ISOnum
- 'sup3': '\263', # superscript three = superscript digit three = cubed, U+00B3 ISOnum
- 'supe': '⊇', # superset of or equal to, U+2287 ISOtech
- 'szlig': '\337', # latin small letter sharp s = ess-zed, U+00DF ISOlat1
- 'tau': 'τ', # greek small letter tau, U+03C4 ISOgrk3
- 'there4': '∴', # therefore, U+2234 ISOtech
- 'theta': 'θ', # greek small letter theta, U+03B8 ISOgrk3
- 'thetasym': 'ϑ', # greek small letter theta symbol, U+03D1 NEW
- 'thinsp': ' ', # thin space, U+2009 ISOpub
- 'thorn': '\376', # latin small letter thorn with, U+00FE ISOlat1
- 'tilde': '˜', # small tilde, U+02DC ISOdia
- 'times': '\327', # multiplication sign, U+00D7 ISOnum
- 'trade': '™', # trade mark sign, U+2122 ISOnum
- 'uArr': '⇑', # upwards double arrow, U+21D1 ISOamsa
- 'uacute': '\372', # latin small letter u with acute, U+00FA ISOlat1
- 'uarr': '↑', # upwards arrow, U+2191 ISOnum
- 'ucirc': '\373', # latin small letter u with circumflex, U+00FB ISOlat1
- 'ugrave': '\371', # latin small letter u with grave, U+00F9 ISOlat1
- 'uml': '\250', # diaeresis = spacing diaeresis, U+00A8 ISOdia
- 'upsih': 'ϒ', # greek upsilon with hook symbol, U+03D2 NEW
- 'upsilon': 'υ', # greek small letter upsilon, U+03C5 ISOgrk3
- 'uuml': '\374', # latin small letter u with diaeresis, U+00FC ISOlat1
- 'weierp': '℘', # script capital P = power set = Weierstrass p, U+2118 ISOamso
- 'xi': 'ξ', # greek small letter xi, U+03BE ISOgrk3
- 'yacute': '\375', # latin small letter y with acute, U+00FD ISOlat1
- 'yen': '\245', # yen sign = yuan sign, U+00A5 ISOnum
- 'yuml': '\377', # latin small letter y with diaeresis, U+00FF ISOlat1
- 'zeta': 'ζ', # greek small letter zeta, U+03B6 ISOgrk3
- 'zwj': '‍', # zero width joiner, U+200D NEW RFC 2070
- 'zwnj': '‌', # zero width non-joiner, U+200C NEW RFC 2070
-
-}
diff --git a/Lib/dos-8x3/linecach.py b/Lib/dos-8x3/linecach.py
deleted file mode 100755
index bca40b2..0000000
--- a/Lib/dos-8x3/linecach.py
+++ /dev/null
@@ -1,92 +0,0 @@
-"""Cache lines from files.
-
-This is intended to read lines from modules imported -- hence if a filename
-is not found, it will look down the module search path for a file by
-that name.
-"""
-
-import sys
-import os
-from stat import *
-
-def getline(filename, lineno):
- lines = getlines(filename)
- if 1 <= lineno <= len(lines):
- return lines[lineno-1]
- else:
- return ''
-
-
-# The cache
-
-cache = {} # The cache
-
-
-def clearcache():
- """Clear the cache entirely."""
-
- global cache
- cache = {}
-
-
-def getlines(filename):
- """Get the lines for a file from the cache.
- Update the cache if it doesn't contain an entry for this file already."""
-
- if cache.has_key(filename):
- return cache[filename][2]
- else:
- return updatecache(filename)
-
-
-def checkcache():
- """Discard cache entries that are out of date.
- (This is not checked upon each call!)"""
-
- for filename in cache.keys():
- size, mtime, lines, fullname = cache[filename]
- try:
- stat = os.stat(fullname)
- except os.error:
- del cache[filename]
- continue
- if size <> stat[ST_SIZE] or mtime <> stat[ST_MTIME]:
- del cache[filename]
-
-
-def updatecache(filename):
- """Update a cache entry and return its list of lines.
- If something's wrong, print a message, discard the cache entry,
- and return an empty list."""
-
- if cache.has_key(filename):
- del cache[filename]
- if not filename or filename[0] + filename[-1] == '<>':
- return []
- fullname = filename
- try:
- stat = os.stat(fullname)
- except os.error, msg:
- # Try looking through the module search path
- basename = os.path.split(filename)[1]
- for dirname in sys.path:
- fullname = os.path.join(dirname, basename)
- try:
- stat = os.stat(fullname)
- break
- except os.error:
- pass
- else:
- # No luck
-## print '*** Cannot stat', filename, ':', msg
- return []
- try:
- fp = open(fullname, 'r')
- lines = fp.readlines()
- fp.close()
- except IOError, msg:
-## print '*** Cannot open', fullname, ':', msg
- return []
- size, mtime = stat[ST_SIZE], stat[ST_MTIME]
- cache[filename] = size, mtime, lines, fullname
- return lines
diff --git a/Lib/dos-8x3/macurl2p.py b/Lib/dos-8x3/macurl2p.py
deleted file mode 100755
index c971eda..0000000
--- a/Lib/dos-8x3/macurl2p.py
+++ /dev/null
@@ -1,94 +0,0 @@
-"""Macintosh-specific module for conversion between pathnames and URLs.
-
-Do not import directly; use urllib instead."""
-
-import string
-import urllib
-import os
-
-def url2pathname(pathname):
- "Convert /-delimited pathname to mac pathname"
- #
- # XXXX The .. handling should be fixed...
- #
- tp = urllib.splittype(pathname)[0]
- if tp and tp <> 'file':
- raise RuntimeError, 'Cannot convert non-local URL to pathname'
- # Turn starting /// into /, an empty hostname means current host
- if pathname[:3] == '///':
- pathname = pathname[2:]
- elif pathname[:2] == '//':
- raise RuntimeError, 'Cannot convert non-local URL to pathname'
- components = string.split(pathname, '/')
- # Remove . and embedded ..
- i = 0
- while i < len(components):
- if components[i] == '.':
- del components[i]
- elif components[i] == '..' and i > 0 and \
- components[i-1] not in ('', '..'):
- del components[i-1:i+1]
- i = i-1
- elif components[i] == '' and i > 0 and components[i-1] <> '':
- del components[i]
- else:
- i = i+1
- if not components[0]:
- # Absolute unix path, don't start with colon
- rv = 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
- rv = ':' + string.join(components, ':')
- # and finally unquote slashes and other funny characters
- return urllib.unquote(rv)
-
-def pathname2url(pathname):
- "convert mac pathname to /-delimited pathname"
- if '/' in pathname:
- raise RuntimeError, "Cannot convert pathname containing slashes"
- components = string.split(pathname, ':')
- # Remove empty first and/or last component
- if components[0] == '':
- del components[0]
- if components[-1] == '':
- del components[-1]
- # Replace empty string ('::') by .. (will result in '/../' later)
- for i in range(len(components)):
- if components[i] == '':
- components[i] = '..'
- # Truncate names longer than 31 bytes
- components = map(_pncomp2url, components)
-
- if os.path.isabs(pathname):
- return '/' + string.join(components, '/')
- else:
- return string.join(components, '/')
-
-def _pncomp2url(component):
- component = urllib.quote(component[:31], safe='') # We want to quote slashes
- return component
-
-def test():
- for url in ["index.html",
- "bar/index.html",
- "/foo/bar/index.html",
- "/foo/bar/",
- "/"]:
- print `url`, '->', `url2pathname(url)`
- for path in ["drive:",
- "drive:dir:",
- "drive:dir:file",
- "drive:file",
- "file",
- ":file",
- ":dir:",
- ":dir:file"]:
- print `path`, '->', `pathname2url(path)`
-
-if __name__ == '__main__':
- test()
diff --git a/Lib/dos-8x3/mimetool.py b/Lib/dos-8x3/mimetool.py
deleted file mode 100755
index da955af..0000000
--- a/Lib/dos-8x3/mimetool.py
+++ /dev/null
@@ -1,229 +0,0 @@
-"""Various tools used by MIME-reading or MIME-writing programs."""
-
-
-import os
-import rfc822
-import string
-import tempfile
-
-
-class Message(rfc822.Message):
- """A derived class of rfc822.Message that knows about MIME headers and
- contains some hooks for decoding encoded and multipart messages."""
-
- def __init__(self, fp, seekable = 1):
- rfc822.Message.__init__(self, fp, seekable)
- self.encodingheader = \
- self.getheader('content-transfer-encoding')
- self.typeheader = \
- self.getheader('content-type')
- self.parsetype()
- self.parseplist()
-
- def parsetype(self):
- str = self.typeheader
- if str == None:
- str = 'text/plain'
- if ';' in str:
- i = string.index(str, ';')
- self.plisttext = str[i:]
- str = str[:i]
- else:
- self.plisttext = ''
- fields = string.splitfields(str, '/')
- for i in range(len(fields)):
- fields[i] = string.lower(string.strip(fields[i]))
- self.type = string.joinfields(fields, '/')
- self.maintype = fields[0]
- self.subtype = string.joinfields(fields[1:], '/')
-
- def parseplist(self):
- str = self.plisttext
- self.plist = []
- while str[:1] == ';':
- str = str[1:]
- if ';' in str:
- # XXX Should parse quotes!
- end = string.index(str, ';')
- else:
- end = len(str)
- f = str[:end]
- if '=' in f:
- i = string.index(f, '=')
- f = string.lower(string.strip(f[:i])) + \
- '=' + string.strip(f[i+1:])
- self.plist.append(string.strip(f))
- str = str[end:]
-
- def getplist(self):
- return self.plist
-
- def getparam(self, name):
- name = string.lower(name) + '='
- n = len(name)
- for p in self.plist:
- if p[:n] == name:
- return rfc822.unquote(p[n:])
- return None
-
- def getparamnames(self):
- result = []
- for p in self.plist:
- i = string.find(p, '=')
- if i >= 0:
- result.append(string.lower(p[:i]))
- return result
-
- def getencoding(self):
- if self.encodingheader == None:
- return '7bit'
- return string.lower(self.encodingheader)
-
- def gettype(self):
- return self.type
-
- def getmaintype(self):
- return self.maintype
-
- def getsubtype(self):
- return self.subtype
-
-
-
-
-# Utility functions
-# -----------------
-
-
-_prefix = None
-
-def choose_boundary():
- """Return a random string usable as a multipart boundary.
- The method used is so that it is *very* unlikely that the same
- string of characters will every occur again in the Universe,
- so the caller needn't check the data it is packing for the
- occurrence of the boundary.
-
- The boundary contains dots so you have to quote it in the header."""
-
- global _prefix
- import time
- import random
- if _prefix == None:
- import socket
- import os
- hostid = socket.gethostbyname(socket.gethostname())
- try:
- uid = `os.getuid()`
- except:
- uid = '1'
- try:
- pid = `os.getpid()`
- except:
- pid = '1'
- _prefix = hostid + '.' + uid + '.' + pid
- timestamp = '%.3f' % time.time()
- seed = `random.randint(0, 32767)`
- return _prefix + '.' + timestamp + '.' + seed
-
-
-# Subroutines for decoding some common content-transfer-types
-
-def decode(input, output, encoding):
- """Decode common content-transfer-encodings (base64, quopri, uuencode)."""
- if encoding == 'base64':
- import base64
- return base64.decode(input, output)
- if encoding == 'quoted-printable':
- import quopri
- return quopri.decode(input, output)
- if encoding in ('uuencode', 'x-uuencode', 'uue', 'x-uue'):
- import uu
- return uu.decode(input, output)
- if encoding in ('7bit', '8bit'):
- return output.write(input.read())
- if decodetab.has_key(encoding):
- pipethrough(input, decodetab[encoding], output)
- else:
- raise ValueError, \
- 'unknown Content-Transfer-Encoding: %s' % encoding
-
-def encode(input, output, encoding):
- """Encode common content-transfer-encodings (base64, quopri, uuencode)."""
- if encoding == 'base64':
- import base64
- return base64.encode(input, output)
- if encoding == 'quoted-printable':
- import quopri
- return quopri.encode(input, output, 0)
- if encoding in ('uuencode', 'x-uuencode', 'uue', 'x-uue'):
- import uu
- return uu.encode(input, output)
- if encoding in ('7bit', '8bit'):
- return output.write(input.read())
- if encodetab.has_key(encoding):
- pipethrough(input, encodetab[encoding], output)
- else:
- raise ValueError, \
- 'unknown Content-Transfer-Encoding: %s' % encoding
-
-# The following is no longer used for standard encodings
-
-# XXX This requires that uudecode and mmencode are in $PATH
-
-uudecode_pipe = '''(
-TEMP=/tmp/@uu.$$
-sed "s%^begin [0-7][0-7]* .*%begin 600 $TEMP%" | uudecode
-cat $TEMP
-rm $TEMP
-)'''
-
-decodetab = {
- 'uuencode': uudecode_pipe,
- 'x-uuencode': uudecode_pipe,
- 'uue': uudecode_pipe,
- 'x-uue': uudecode_pipe,
- 'quoted-printable': 'mmencode -u -q',
- 'base64': 'mmencode -u -b',
-}
-
-encodetab = {
- 'x-uuencode': 'uuencode tempfile',
- 'uuencode': 'uuencode tempfile',
- 'x-uue': 'uuencode tempfile',
- 'uue': 'uuencode tempfile',
- 'quoted-printable': 'mmencode -q',
- 'base64': 'mmencode -b',
-}
-
-def pipeto(input, command):
- pipe = os.popen(command, 'w')
- copyliteral(input, pipe)
- pipe.close()
-
-def pipethrough(input, command, output):
- tempname = tempfile.mktemp()
- try:
- temp = open(tempname, 'w')
- except IOError:
- print '*** Cannot create temp file', `tempname`
- return
- copyliteral(input, temp)
- temp.close()
- pipe = os.popen(command + ' <' + tempname, 'r')
- copybinary(pipe, output)
- pipe.close()
- os.unlink(tempname)
-
-def copyliteral(input, output):
- while 1:
- line = input.readline()
- if not line: break
- output.write(line)
-
-def copybinary(input, output):
- BUFSIZE = 8192
- while 1:
- line = input.read(BUFSIZE)
- if not line: break
- output.write(line)
diff --git a/Lib/dos-8x3/mimetype.py b/Lib/dos-8x3/mimetype.py
deleted file mode 100644
index 9dc3645..0000000
--- a/Lib/dos-8x3/mimetype.py
+++ /dev/null
@@ -1,237 +0,0 @@
-"""Guess the MIME type of a file.
-
-This module defines two useful functions:
-
-guess_type(url) -- guess the MIME type and encoding of a URL.
-
-guess_extension(type) -- guess the extension for a given MIME type.
-
-It also contains the following, for tuning the behavior:
-
-Data:
-
-knownfiles -- list of files to parse
-inited -- flag set when init() has been called
-suffixes_map -- dictionary mapping suffixes to suffixes
-encodings_map -- dictionary mapping suffixes to encodings
-types_map -- dictionary mapping suffixes to types
-
-Functions:
-
-init([files]) -- parse a list of files, default knownfiles
-read_mime_types(file) -- parse one file, return a dictionary or None
-
-"""
-
-import string
-import posixpath
-import urllib
-
-knownfiles = [
- "/usr/local/etc/httpd/conf/mime.types",
- "/usr/local/lib/netscape/mime.types",
- "/usr/local/etc/httpd/conf/mime.types", # Apache 1.2
- "/usr/local/etc/mime.types", # Apache 1.3
- ]
-
-inited = 0
-
-def guess_type(url):
- """Guess the type of a file based on its URL.
-
- Return value is a tuple (type, encoding) where type is None if the
- type can't be guessed (no or unknown suffix) or a string of the
- form type/subtype, usable for a MIME Content-type header; and
- encoding is None for no encoding or the name of the program used
- to encode (e.g. compress or gzip). The mappings are table
- driven. Encoding suffixes are case sensitive; type suffixes are
- first tried case sensitive, then case insensitive.
-
- The suffixes .tgz, .taz and .tz (case sensitive!) are all mapped
- to ".tar.gz". (This is table-driven too, using the dictionary
- suffix_map).
-
- """
- if not inited:
- init()
- scheme, url = urllib.splittype(url)
- if scheme == 'data':
- # syntax of data URLs:
- # dataurl := "data:" [ mediatype ] [ ";base64" ] "," data
- # mediatype := [ type "/" subtype ] *( ";" parameter )
- # data := *urlchar
- # parameter := attribute "=" value
- # type/subtype defaults to "text/plain"
- comma = string.find(url, ',')
- if comma < 0:
- # bad data URL
- return None, None
- semi = string.find(url, ';', 0, comma)
- if semi >= 0:
- type = url[:semi]
- else:
- type = url[:comma]
- if '=' in type or '/' not in type:
- type = 'text/plain'
- return type, None # never compressed, so encoding is None
- base, ext = posixpath.splitext(url)
- while suffix_map.has_key(ext):
- base, ext = posixpath.splitext(base + suffix_map[ext])
- if encodings_map.has_key(ext):
- encoding = encodings_map[ext]
- base, ext = posixpath.splitext(base)
- else:
- encoding = None
- if types_map.has_key(ext):
- return types_map[ext], encoding
- elif types_map.has_key(string.lower(ext)):
- return types_map[string.lower(ext)], encoding
- else:
- return None, encoding
-
-def guess_extension(type):
- """Guess the extension for a file based on its MIME type.
-
- Return value is a string giving a filename extension, including the
- leading dot ('.'). The extension is not guaranteed to have been
- associated with any particular data stream, but would be mapped to the
- MIME type `type' by guess_type(). If no extension can be guessed for
- `type', None is returned.
- """
- global inited
- if not inited:
- init()
- type = string.lower(type)
- for ext, stype in types_map.items():
- if type == stype:
- return ext
- return None
-
-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
- inited = 1
-
-def read_mime_types(file):
- try:
- f = open(file)
- except IOError:
- 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
- f.close()
- return map
-
-suffix_map = {
- '.tgz': '.tar.gz',
- '.taz': '.tar.gz',
- '.tz': '.tar.gz',
-}
-
-encodings_map = {
- '.gz': 'gzip',
- '.Z': 'compress',
- }
-
-types_map = {
- '.a': 'application/octet-stream',
- '.ai': 'application/postscript',
- '.aif': 'audio/x-aiff',
- '.aifc': 'audio/x-aiff',
- '.aiff': 'audio/x-aiff',
- '.au': 'audio/basic',
- '.avi': 'video/x-msvideo',
- '.bcpio': 'application/x-bcpio',
- '.bin': 'application/octet-stream',
- '.cdf': 'application/x-netcdf',
- '.cpio': 'application/x-cpio',
- '.csh': 'application/x-csh',
- '.dll': 'application/octet-stream',
- '.dvi': 'application/x-dvi',
- '.exe': 'application/octet-stream',
- '.eps': 'application/postscript',
- '.etx': 'text/x-setext',
- '.gif': 'image/gif',
- '.gtar': 'application/x-gtar',
- '.hdf': 'application/x-hdf',
- '.htm': 'text/html',
- '.html': 'text/html',
- '.ief': 'image/ief',
- '.jpe': 'image/jpeg',
- '.jpeg': 'image/jpeg',
- '.jpg': 'image/jpeg',
- '.js': 'application/x-javascript',
- '.latex': 'application/x-latex',
- '.man': 'application/x-troff-man',
- '.me': 'application/x-troff-me',
- '.mif': 'application/x-mif',
- '.mov': 'video/quicktime',
- '.movie': 'video/x-sgi-movie',
- '.mpe': 'video/mpeg',
- '.mpeg': 'video/mpeg',
- '.mpg': 'video/mpeg',
- '.ms': 'application/x-troff-ms',
- '.nc': 'application/x-netcdf',
- '.o': 'application/octet-stream',
- '.obj': 'application/octet-stream',
- '.oda': 'application/oda',
- '.pbm': 'image/x-portable-bitmap',
- '.pdf': 'application/pdf',
- '.pgm': 'image/x-portable-graymap',
- '.pnm': 'image/x-portable-anymap',
- '.png': 'image/png',
- '.ppm': 'image/x-portable-pixmap',
- '.py': 'text/x-python',
- '.pyc': 'application/x-python-code',
- '.ps': 'application/postscript',
- '.qt': 'video/quicktime',
- '.ras': 'image/x-cmu-raster',
- '.rgb': 'image/x-rgb',
- '.rdf': 'application/xml',
- '.roff': 'application/x-troff',
- '.rtf': 'application/rtf',
- '.rtx': 'text/richtext',
- '.sgm': 'text/x-sgml',
- '.sgml': 'text/x-sgml',
- '.sh': 'application/x-sh',
- '.shar': 'application/x-shar',
- '.snd': 'audio/basic',
- '.so': 'application/octet-stream',
- '.src': 'application/x-wais-source',
- '.sv4cpio': 'application/x-sv4cpio',
- '.sv4crc': 'application/x-sv4crc',
- '.t': 'application/x-troff',
- '.tar': 'application/x-tar',
- '.tcl': 'application/x-tcl',
- '.tex': 'application/x-tex',
- '.texi': 'application/x-texinfo',
- '.texinfo': 'application/x-texinfo',
- '.tif': 'image/tiff',
- '.tiff': 'image/tiff',
- '.tr': 'application/x-troff',
- '.tsv': 'text/tab-separated-values',
- '.txt': 'text/plain',
- '.ustar': 'application/x-ustar',
- '.wav': 'audio/x-wav',
- '.xbm': 'image/x-xbitmap',
- '.xml': 'text/xml',
- '.xsl': 'application/xml',
- '.xpm': 'image/x-xpixmap',
- '.xwd': 'image/x-xwindowdump',
- '.zip': 'application/zip',
- }
diff --git a/Lib/dos-8x3/mimewrit.py b/Lib/dos-8x3/mimewrit.py
deleted file mode 100644
index 754576b..0000000
--- a/Lib/dos-8x3/mimewrit.py
+++ /dev/null
@@ -1,128 +0,0 @@
-"""Generic MIME writer.
-
-Classes:
-
-MimeWriter - the only thing here.
-
-"""
-
-
-import string
-import mimetools
-
-
-class MimeWriter:
-
- """Generic MIME writer.
-
- Methods:
-
- __init__()
- addheader()
- flushheaders()
- startbody()
- startmultipartbody()
- nextpart()
- lastpart()
-
- A MIME writer is much more primitive than a MIME parser. It
- doesn't seek around on the output file, and it doesn't use large
- amounts of buffer space, so you have to write the parts in the
- order they should occur on the output file. It does buffer the
- headers you add, allowing you to rearrange their order.
-
- General usage is:
-
- f = <open the output file>
- w = MimeWriter(f)
- ...call w.addheader(key, value) 0 or more times...
-
- followed by either:
-
- f = w.startbody(content_type)
- ...call f.write(data) for body data...
-
- or:
-
- w.startmultipartbody(subtype)
- for each part:
- subwriter = w.nextpart()
- ...use the subwriter's methods to create the subpart...
- w.lastpart()
-
- The subwriter is another MimeWriter instance, and should be
- treated in the same way as the toplevel MimeWriter. This way,
- writing recursive body parts is easy.
-
- Warning: don't forget to call lastpart()!
-
- XXX There should be more state so calls made in the wrong order
- are detected.
-
- Some special cases:
-
- - startbody() just returns the file passed to the constructor;
- but don't use this knowledge, as it may be changed.
-
- - startmultipartbody() actually returns a file as well;
- this can be used to write the initial 'if you can read this your
- mailer is not MIME-aware' message.
-
- - If you call flushheaders(), the headers accumulated so far are
- written out (and forgotten); this is useful if you don't need a
- body part at all, e.g. for a subpart of type message/rfc822
- that's (mis)used to store some header-like information.
-
- - Passing a keyword argument 'prefix=<flag>' to addheader(),
- start*body() affects where the header is inserted; 0 means
- append at the end, 1 means insert at the start; default is
- append for addheader(), but insert for start*body(), which use
- it to determine where the Content-Type header goes.
-
- """
-
- def __init__(self, fp):
- 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)
-
- def flushheaders(self):
- 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
-
- 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)
-
- def nextpart(self):
- self._fp.write("\n--" + self._boundary + "\n")
- return self.__class__(self._fp)
-
- def lastpart(self):
- self._fp.write("\n--" + self._boundary + "--\n")
-
-
-if __name__ == '__main__':
- import test.test_MimeWriter
diff --git a/Lib/dos-8x3/multifil.py b/Lib/dos-8x3/multifil.py
deleted file mode 100755
index e43d331..0000000
--- a/Lib/dos-8x3/multifil.py
+++ /dev/null
@@ -1,164 +0,0 @@
-"""A readline()-style interface to the parts of a multipart message.
-
-The MultiFile class makes each part of a multipart message "feel" like
-an ordinary file, as long as you use fp.readline(). Allows recursive
-use, for nested multipart messages. Probably best used together
-with module mimetools.
-
-Suggested use:
-
-real_fp = open(...)
-fp = MultiFile(real_fp)
-
-"read some lines from fp"
-fp.push(separator)
-while 1:
- "read lines from fp until it returns an empty string" (A)
- if not fp.next(): break
-fp.pop()
-"read remaining lines from fp until it returns an empty string"
-
-The latter sequence may be used recursively at (A).
-It is also allowed to use multiple push()...pop() sequences.
-
-If seekable is given as 0, the class code will not do the bookkeeping
-it normally attempts in order to make seeks relative to the beginning of the
-current file part. This may be useful when using MultiFile with a non-
-seekable stream object.
-"""
-
-import sys
-import string
-
-class Error(Exception):
- pass
-
-class MultiFile:
-
- seekable = 0
-
- def __init__(self, fp, seekable=1):
- self.fp = fp
- self.stack = [] # Grows down
- self.level = 0
- self.last = 0
- if seekable:
- self.seekable = 1
- self.start = self.fp.tell()
- self.posstack = [] # Grows down
-
- def tell(self):
- if self.level > 0:
- return self.lastpos
- return self.fp.tell() - self.start
-
- def seek(self, pos, 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)
- self.level = 0
- self.last = 0
-
- def readline(self):
- if self.level > 0:
- return ''
- line = self.fp.readline()
- # Real EOF?
- if not line:
- self.level = len(self.stack)
- self.last = (self.level > 0)
- if self.last:
- raise Error, 'sudden EOF in MultiFile.readline()'
- return ''
- assert self.level == 0
- # Fast check to see if this is just data
- if self.is_data(line):
- return line
- else:
- # Ignore trailing whitespace on marker lines
- k = len(line) - 1;
- while line[k] in string.whitespace:
- k = k - 1
- marker = line[:k+1]
- # No? OK, try to match a boundary.
- # Return the line (unstripped) if we don't.
- for i in range(len(self.stack)):
- sep = self.stack[i]
- if marker == self.section_divider(sep):
- self.last = 0
- break
- elif marker == self.end_marker(sep):
- self.last = 1
- break
- else:
- return line
- # We only get here if we see a section divider or EOM line
- if self.seekable:
- self.lastpos = self.tell() - len(line)
- self.level = i+1
- if self.level > 1:
- raise Error,'Missing endmarker in MultiFile.readline()'
- return ''
-
- def readlines(self):
- list = []
- while 1:
- line = self.readline()
- if not line: break
- list.append(line)
- return list
-
- def read(self): # Note: no size argument -- read until EOF only!
- return string.joinfields(self.readlines(), '')
-
- def next(self):
- while self.readline(): pass
- if self.level > 1 or self.last:
- return 0
- self.level = 0
- self.last = 0
- if self.seekable:
- self.start = self.fp.tell()
- return 1
-
- def push(self, sep):
- if self.level > 0:
- raise Error, 'bad MultiFile.push() call'
- self.stack.insert(0, sep)
- if self.seekable:
- self.posstack.insert(0, self.start)
- self.start = self.fp.tell()
-
- def pop(self):
- if self.stack == []:
- raise Error, 'bad MultiFile.pop() call'
- if self.level <= 1:
- self.last = 0
- else:
- abslastpos = self.lastpos + self.start
- self.level = max(0, self.level - 1)
- del self.stack[0]
- if self.seekable:
- self.start = self.posstack[0]
- del self.posstack[0]
- if self.level > 0:
- self.lastpos = abslastpos - self.start
-
- def is_data(self, line):
- return line[:2] <> '--'
-
- def section_divider(self, str):
- return "--" + str
-
- def end_marker(self, str):
- return "--" + str + "--"
diff --git a/Lib/dos-8x3/nturl2pa.py b/Lib/dos-8x3/nturl2pa.py
deleted file mode 100755
index 0445b8a..0000000
--- a/Lib/dos-8x3/nturl2pa.py
+++ /dev/null
@@ -1,66 +0,0 @@
-"""Convert a NT pathname to a file URL and vice versa."""
-
-def url2pathname(url):
- r"""Convert a URL to a DOS path.
-
- ///C|/foo/bar/spam.foo
-
- becomes
-
- C:\foo\bar\spam.foo
- """
- import string, urllib
- if not '|' in url:
- # No drive specifier, just convert slashes
- if url[:4] == '////':
- # path is something like ////host/path/on/remote/host
- # convert this to \\host\path\on\remote\host
- # (notice halving of slashes at the start of the path)
- url = url[2:]
- components = string.split(url, '/')
- # make sure not to convert quoted slashes :-)
- return urllib.unquote(string.join(components, '\\'))
- comp = string.split(url, '|')
- if len(comp) != 2 or comp[0][-1] not in string.letters:
- error = 'Bad URL: ' + url
- raise IOError, error
- drive = string.upper(comp[0][-1])
- components = string.split(comp[1], '/')
- path = drive + ':'
- for comp in components:
- if comp:
- path = path + '\\' + urllib.unquote(comp)
- return path
-
-def pathname2url(p):
- r"""Convert a DOS path name to a file url.
-
- C:\foo\bar\spam.foo
-
- becomes
-
- ///C|/foo/bar/spam.foo
- """
-
- import string, urllib
- if not ':' in p:
- # No drive specifier, just convert slashes and quote the name
- if p[:2] == '\\\\':
- # path is something like \\host\path\on\remote\host
- # convert this to ////host/path/on/remote/host
- # (notice doubling of slashes at the start of the path)
- p = '\\\\' + p
- components = string.split(p, '\\')
- return urllib.quote(string.join(components, '/'))
- comp = string.split(p, ':')
- if len(comp) != 2 or len(comp[0]) > 1:
- error = 'Bad path: ' + p
- raise IOError, error
-
- drive = urllib.quote(string.upper(comp[0]))
- components = string.split(comp[1], '\\')
- path = '///' + drive + '|'
- for comp in components:
- if comp:
- path = path + '/' + urllib.quote(comp)
- return path
diff --git a/Lib/dos-8x3/posixfil.py b/Lib/dos-8x3/posixfil.py
deleted file mode 100755
index 23f2c85..0000000
--- a/Lib/dos-8x3/posixfil.py
+++ /dev/null
@@ -1,229 +0,0 @@
-"""Extended file operations available in POSIX.
-
-f = posixfile.open(filename, [mode, [bufsize]])
- will create a new posixfile object
-
-f = posixfile.fileopen(fileobject)
- will create a posixfile object from a builtin file object
-
-f.file()
- will return the original builtin file object
-
-f.dup()
- will return a new file object based on a new filedescriptor
-
-f.dup2(fd)
- will return a new file object based on the given filedescriptor
-
-f.flags(mode)
- will turn on the associated flag (merge)
- mode can contain the following characters:
-
- (character representing a flag)
- a append only flag
- c close on exec flag
- n no delay flag
- s synchronization flag
- (modifiers)
- ! turn flags 'off' instead of default 'on'
- = copy flags 'as is' instead of default 'merge'
- ? return a string in which the characters represent the flags
- that are set
-
- note: - the '!' and '=' modifiers are mutually exclusive.
- - the '?' modifier will return the status of the flags after they
- have been changed by other characters in the mode string
-
-f.lock(mode [, len [, start [, whence]]])
- will (un)lock a region
- mode can contain the following characters:
-
- (character representing type of lock)
- u unlock
- r read lock
- w write lock
- (modifiers)
- | wait until the lock can be granted
- ? return the first lock conflicting with the requested lock
- or 'None' if there is no conflict. The lock returned is in the
- format (mode, len, start, whence, pid) where mode is a
- character representing the type of lock ('r' or 'w')
-
- note: - the '?' modifier prevents a region from being locked; it is
- query only
-"""
-
-class _posixfile_:
- """File wrapper class that provides extra POSIX file routines."""
-
- states = ['open', 'closed']
-
- #
- # Internal routines
- #
- def __repr__(self):
- file = self._file_
- return "<%s posixfile '%s', mode '%s' at %s>" % \
- (self.states[file.closed], file.name, file.mode, \
- hex(id(self))[2:])
-
- #
- # Initialization routines
- #
- def open(self, name, mode='r', bufsize=-1):
- import __builtin__
- return self.fileopen(__builtin__.open(name, mode, bufsize))
-
- def fileopen(self, file):
- if `type(file)` != "<type 'file'>":
- raise TypeError, 'posixfile.fileopen() arg must be file object'
- self._file_ = file
- # Copy basic file methods
- for method in file.__methods__:
- setattr(self, method, getattr(file, method))
- return self
-
- #
- # New methods
- #
- def file(self):
- return self._file_
-
- def dup(self):
- import posix
-
- try: ignore = posix.fdopen
- except: raise AttributeError, 'dup() method unavailable'
-
- return posix.fdopen(posix.dup(self._file_.fileno()), self._file_.mode)
-
- def dup2(self, fd):
- import posix
-
- try: ignore = posix.fdopen
- except: raise AttributeError, 'dup() method unavailable'
-
- posix.dup2(self._file_.fileno(), fd)
- return posix.fdopen(fd, self._file_.mode)
-
- def flags(self, *which):
- import fcntl, FCNTL
-
- if which:
- if len(which) > 1:
- raise TypeError, 'Too many arguments'
- which = which[0]
- else: which = '?'
-
- l_flags = 0
- if 'n' in which: l_flags = l_flags | FCNTL.O_NDELAY
- if 'a' in which: l_flags = l_flags | FCNTL.O_APPEND
- if 's' in which: l_flags = l_flags | FCNTL.O_SYNC
-
- file = self._file_
-
- if '=' not in which:
- cur_fl = fcntl.fcntl(file.fileno(), FCNTL.F_GETFL, 0)
- if '!' in which: l_flags = cur_fl & ~ l_flags
- else: l_flags = cur_fl | l_flags
-
- l_flags = fcntl.fcntl(file.fileno(), FCNTL.F_SETFL, l_flags)
-
- if 'c' in which:
- arg = ('!' not in which) # 0 is don't, 1 is do close on exec
- l_flags = fcntl.fcntl(file.fileno(), FCNTL.F_SETFD, arg)
-
- if '?' in which:
- which = '' # Return current flags
- l_flags = fcntl.fcntl(file.fileno(), FCNTL.F_GETFL, 0)
- if FCNTL.O_APPEND & l_flags: which = which + 'a'
- if fcntl.fcntl(file.fileno(), FCNTL.F_GETFD, 0) & 1:
- which = which + 'c'
- if FCNTL.O_NDELAY & l_flags: which = which + 'n'
- if FCNTL.O_SYNC & l_flags: which = which + 's'
- return which
-
- def lock(self, how, *args):
- import struct, fcntl, FCNTL
-
- if 'w' in how: l_type = FCNTL.F_WRLCK
- elif 'r' in how: l_type = FCNTL.F_RDLCK
- elif 'u' in how: l_type = FCNTL.F_UNLCK
- else: raise TypeError, 'no type of lock specified'
-
- if '|' in how: cmd = FCNTL.F_SETLKW
- elif '?' in how: cmd = FCNTL.F_GETLK
- else: cmd = FCNTL.F_SETLK
-
- l_whence = 0
- l_start = 0
- l_len = 0
-
- if len(args) == 1:
- l_len = args[0]
- elif len(args) == 2:
- l_len, l_start = args
- elif len(args) == 3:
- l_len, l_start, l_whence = args
- elif len(args) > 3:
- raise TypeError, 'too many arguments'
-
- # 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',
- 'openbsd2',
- 'freebsd2', 'freebsd3', 'freebsd4', 'freebsd5',
- 'bsdos2', 'bsdos3', 'bsdos4'):
- 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)
-
- flock = fcntl.fcntl(self._file_.fileno(), cmd, flock)
-
- if '?' in how:
- if sys.platform in ('netbsd1',
- 'openbsd2',
- 'freebsd2', 'freebsd3', 'freebsd4', 'freebsd5',
- 'bsdos2', 'bsdos3', 'bsdos4'):
- 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
-
-def open(name, mode='r', bufsize=-1):
- """Public routine to open a file as a posixfile object."""
- return _posixfile_().open(name, mode, bufsize)
-
-def fileopen(file):
- """Public routine to get a posixfile object from a Python file object."""
- return _posixfile_().fileopen(file)
-
-#
-# Constants
-#
-SEEK_SET = 0
-SEEK_CUR = 1
-SEEK_END = 2
-
-#
-# End of posixfile.py
-#
diff --git a/Lib/dos-8x3/posixpat.py b/Lib/dos-8x3/posixpat.py
deleted file mode 100755
index 2826604..0000000
--- a/Lib/dos-8x3/posixpat.py
+++ /dev/null
@@ -1,368 +0,0 @@
-"""Common operations on Posix pathnames.
-
-Instead of importing this module directly, import os and refer to
-this module as os.path. The "os.path" name is an alias for this
-module on Posix systems; on other systems (e.g. Mac, Windows),
-os.path provides the same operations in a manner specific to that
-platform, and is an alias to another module (e.g. macpath, ntpath).
-
-Some of this can actually be useful on non-Posix systems too, e.g.
-for manipulation of the pathname component of URLs.
-"""
-
-import os
-import stat
-
-
-# Normalize the case of a pathname. Trivial in Posix, string.lower on Mac.
-# On MS-DOS this may also turn slashes into backslashes; however, other
-# normalizations (such as optimizing '../' away) are not allowed
-# (another function should be defined to do that).
-
-def normcase(s):
- """Normalize case of pathname. Has no effect under Posix"""
- return s
-
-
-# Return whether a path is absolute.
-# Trivial in Posix, harder on the Mac or MS-DOS.
-
-def isabs(s):
- """Test whether a path is absolute"""
- return s[:1] == '/'
-
-
-# Join pathnames.
-# Ignore the previous parts if a part is absolute.
-# Insert a '/' unless the first part is empty or already ends in '/'.
-
-def join(a, *p):
- """Join two or more pathname components, inserting '/' as needed"""
- path = a
- for b in p:
- if b[:1] == '/':
- path = b
- elif path == '' or path[-1:] == '/':
- path = path + b
- else:
- path = path + '/' + b
- return path
-
-
-# Split a path in head (everything up to the last '/') and tail (the
-# rest). If the path ends in '/', tail will be empty. If there is no
-# '/' in the path, head will be empty.
-# Trailing '/'es are stripped from head unless it is the root.
-
-def split(p):
- """Split a pathname. Returns tuple "(head, tail)" where "tail" is
- everything after the final slash. Either part may be empty."""
- i = p.rfind('/') + 1
- head, tail = p[:i], p[i:]
- if head and head <> '/'*len(head):
- while head[-1] == '/':
- head = head[:-1]
- return head, tail
-
-
-# Split a path in root and extension.
-# The extension is everything starting at the last dot in the last
-# pathname component; the root is everything before that.
-# It is always true that root + ext == p.
-
-def splitext(p):
- """Split the extension from a pathname. Extension is everything from the
- last dot to the end. Returns "(root, ext)", either part may be empty."""
- root, ext = '', ''
- for c in p:
- if c == '/':
- root, ext = root + ext + c, ''
- elif c == '.':
- if ext:
- root, ext = root + ext, c
- else:
- ext = c
- elif ext:
- ext = ext + c
- else:
- root = root + c
- return root, ext
-
-
-# Split a pathname into a drive specification and the rest of the
-# path. Useful on DOS/Windows/NT; on Unix, the drive is always empty.
-
-def splitdrive(p):
- """Split a pathname into drive and path. On Posix, drive is always
- empty."""
- return '', p
-
-
-# Return the tail (basename) part of a path.
-
-def basename(p):
- """Returns the final component of a pathname"""
- return split(p)[1]
-
-
-# Return the head (dirname) part of a path.
-
-def dirname(p):
- """Returns the directory component of a pathname"""
- return split(p)[0]
-
-
-# Return the longest prefix of all list elements.
-
-def commonprefix(m):
- "Given a list of pathnames, returns the longest common leading component"
- if not m: return ''
- prefix = m[0]
- for item in m:
- for i in range(len(prefix)):
- if prefix[:i+1] <> item[:i+1]:
- prefix = prefix[:i]
- if i == 0: return ''
- break
- return prefix
-
-
-# Get size, mtime, atime of files.
-
-def getsize(filename):
- """Return the size of a file, reported by os.stat()."""
- st = os.stat(filename)
- return st[stat.ST_SIZE]
-
-def getmtime(filename):
- """Return the last modification time of a file, reported by os.stat()."""
- st = os.stat(filename)
- return st[stat.ST_MTIME]
-
-def getatime(filename):
- """Return the last access time of a file, reported by os.stat()."""
- st = os.stat(filename)
- return st[stat.ST_ATIME]
-
-
-# Is a path a symbolic link?
-# This will always return false on systems where os.lstat doesn't exist.
-
-def islink(path):
- """Test whether a path is a symbolic link"""
- try:
- st = os.lstat(path)
- except (os.error, AttributeError):
- return 0
- return stat.S_ISLNK(st[stat.ST_MODE])
-
-
-# Does a path exist?
-# This is false for dangling symbolic links.
-
-def exists(path):
- """Test whether a path exists. Returns false for broken symbolic links"""
- try:
- st = os.stat(path)
- except os.error:
- return 0
- return 1
-
-
-# Is a path a directory?
-# This follows symbolic links, so both islink() and isdir() can be true
-# for the same path.
-
-def isdir(path):
- """Test whether a path is a directory"""
- try:
- st = os.stat(path)
- except os.error:
- return 0
- return stat.S_ISDIR(st[stat.ST_MODE])
-
-
-# Is a path a regular file?
-# This follows symbolic links, so both islink() and isfile() can be true
-# for the same path.
-
-def isfile(path):
- """Test whether a path is a regular file"""
- try:
- st = os.stat(path)
- except os.error:
- return 0
- return stat.S_ISREG(st[stat.ST_MODE])
-
-
-# Are two filenames really pointing to the same file?
-
-def samefile(f1, f2):
- """Test whether two pathnames reference the same actual file"""
- s1 = os.stat(f1)
- s2 = os.stat(f2)
- return samestat(s1, s2)
-
-
-# Are two open files really referencing the same file?
-# (Not necessarily the same file descriptor!)
-
-def sameopenfile(fp1, fp2):
- """Test whether two open file objects reference the same file"""
- s1 = os.fstat(fp1)
- s2 = os.fstat(fp2)
- return samestat(s1, s2)
-
-
-# Are two stat buffers (obtained from stat, fstat or lstat)
-# describing the same file?
-
-def samestat(s1, s2):
- """Test whether two stat buffers reference the same file"""
- return s1[stat.ST_INO] == s2[stat.ST_INO] and \
- s1[stat.ST_DEV] == s2[stat.ST_DEV]
-
-
-# Is a path a mount point?
-# (Does this work for all UNIXes? Is it even guaranteed to work by Posix?)
-
-def ismount(path):
- """Test whether a path is a mount point"""
- try:
- s1 = os.stat(path)
- s2 = os.stat(join(path, '..'))
- except os.error:
- return 0 # It doesn't exist -- so not a mount point :-)
- dev1 = s1[stat.ST_DEV]
- dev2 = s2[stat.ST_DEV]
- if dev1 != dev2:
- return 1 # path/.. on a different device as path
- ino1 = s1[stat.ST_INO]
- ino2 = s2[stat.ST_INO]
- if ino1 == ino2:
- return 1 # path/.. is the same i-node as path
- return 0
-
-
-# Directory tree walk.
-# For each directory under top (including top itself, but excluding
-# '.' and '..'), func(arg, dirname, filenames) is called, where
-# dirname is the name of the directory and filenames is the list
-# of files (and subdirectories etc.) in the directory.
-# The func may modify the filenames list, to implement a filter,
-# or to impose a different order of visiting.
-
-def walk(top, func, arg):
- """walk(top,func,arg) calls func(arg, d, files) for each directory "d"
- in the tree rooted at "top" (including "top" itself). "files" is a list
- of all the files and subdirs in directory "d".
- """
- try:
- names = os.listdir(top)
- except os.error:
- return
- func(arg, top, names)
- for name in names:
- name = join(top, name)
- st = os.lstat(name)
- if stat.S_ISDIR(st[stat.ST_MODE]):
- walk(name, func, arg)
-
-
-# Expand paths beginning with '~' or '~user'.
-# '~' means $HOME; '~user' means that user's home directory.
-# If the path doesn't begin with '~', or if the user or $HOME is unknown,
-# the path is returned unchanged (leaving error reporting to whatever
-# function is called with the expanded path as argument).
-# See also module 'glob' for expansion of *, ? and [...] in pathnames.
-# (A function should also be defined to do full *sh-style environment
-# variable expansion.)
-
-def expanduser(path):
- """Expand ~ and ~user constructions. If user or $HOME is unknown,
- do nothing."""
- if path[:1] <> '~':
- return path
- i, n = 1, len(path)
- while i < n and path[i] <> '/':
- i = i + 1
- if i == 1:
- if not os.environ.has_key('HOME'):
- return path
- userhome = os.environ['HOME']
- else:
- import pwd
- try:
- pwent = pwd.getpwnam(path[1:i])
- except KeyError:
- return path
- userhome = pwent[5]
- if userhome[-1:] == '/': i = i + 1
- return userhome + path[i:]
-
-
-# Expand paths containing shell variable substitutions.
-# This expands the forms $variable and ${variable} only.
-# Non-existent variables are left unchanged.
-
-_varprog = None
-
-def expandvars(path):
- """Expand shell variables of form $var and ${var}. Unknown variables
- are left unchanged."""
- global _varprog
- if '$' not in path:
- return path
- if not _varprog:
- import re
- _varprog = re.compile(r'\$(\w+|\{[^}]*\})')
- i = 0
- while 1:
- m = _varprog.search(path, i)
- if not m:
- break
- i, j = m.span(0)
- name = m.group(1)
- if name[:1] == '{' and name[-1:] == '}':
- name = name[1:-1]
- if os.environ.has_key(name):
- tail = path[j:]
- path = path[:i] + os.environ[name]
- i = len(path)
- path = path + tail
- else:
- i = j
- return path
-
-
-# Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A/B.
-# It should be understood that this may change the meaning of the path
-# if it contains symbolic links!
-
-def normpath(path):
- """Normalize path, eliminating double slashes, etc."""
- if path == '':
- return '.'
- initial_slash = (path[0] == '/')
- comps = path.split('/')
- new_comps = []
- for comp in comps:
- if comp in ('', '.'):
- continue
- if (comp != '..' or (not initial_slash and not new_comps) or
- (new_comps and new_comps[-1] == '..')):
- new_comps.append(comp)
- elif new_comps:
- new_comps.pop()
- comps = new_comps
- path = '/'.join(comps)
- if initial_slash:
- path = '/' + path
- return path or '.'
-
-
-def abspath(path):
- """Return an absolute path."""
- if not isabs(path):
- path = join(os.getcwd(), path)
- return normpath(path)
diff --git a/Lib/dos-8x3/py_compi.py b/Lib/dos-8x3/py_compi.py
deleted file mode 100755
index b453109..0000000
--- a/Lib/dos-8x3/py_compi.py
+++ /dev/null
@@ -1,80 +0,0 @@
-"""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):
- """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 = long(os.fstat(f.fileno())[8])
- except AttributeError:
- timestamp = long(os.stat(file)[8])
- codestring = f.read()
- # If parsing from a string, line breaks are \n (see parsetok.c:tok_nextc)
- # Replace will return original string if pattern is not found, so
- # we don't need to check whether it is found first.
- codestring = codestring.replace("\r\n","\n")
- codestring = codestring.replace("\r","\n")
- f.close()
- if codestring and codestring[-1] != '\n':
- codestring = codestring + '\n'
- try:
- codeobject = __builtin__.compile(codestring, dfile or file, 'exec')
- except SyntaxError, detail:
- import traceback, sys, string
- lines = traceback.format_exception_only(SyntaxError, detail)
- for line in lines:
- sys.stderr.write(string.replace(line, 'File "<string>"',
- 'File "%s"' % (dfile or file)))
- return
- 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 ')
diff --git a/Lib/dos-8x3/queue.py b/Lib/dos-8x3/queue.py
deleted file mode 100755
index 9d5f799..0000000
--- a/Lib/dos-8x3/queue.py
+++ /dev/null
@@ -1,138 +0,0 @@
-"""A multi-producer, multi-consumer queue."""
-
-# define this exception to be compatible with Python 1.5's class
-# exceptions, but also when -X option is used.
-try:
- class Empty(Exception):
- pass
- class Full(Exception):
- pass
-except TypeError:
- # string based exceptions
- # exception raised by get(block=0)/get_nowait()
- Empty = 'Queue.Empty'
- # exception raised by put(block=0)/put_nowait()
- Full = 'Queue.Full'
-
-class Queue:
- def __init__(self, maxsize=0):
- """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()
- self.fsema = thread.allocate_lock()
-
- def qsize(self):
- """Return the approximate size of the queue (not reliable!)."""
- self.mutex.acquire()
- n = self._qsize()
- self.mutex.release()
- return n
-
- def empty(self):
- """Return 1 if the queue is empty, 0 otherwise (not reliable!)."""
- self.mutex.acquire()
- n = self._empty()
- self.mutex.release()
- return n
-
- def full(self):
- """Return 1 if the queue is full, 0 otherwise (not reliable!)."""
- self.mutex.acquire()
- n = self._full()
- self.mutex.release()
- return n
-
- def put(self, item, block=1):
- """Put an item into the queue.
-
- If optional arg 'block' is 1 (the default), block if
- necessary until a free slot is available. Otherwise (block
- is 0), put an item on the queue if a free slot is immediately
- available, else raise the Full exception.
- """
- if block:
- self.fsema.acquire()
- elif not self.fsema.acquire(0):
- raise Full
- self.mutex.acquire()
- was_empty = self._empty()
- self._put(item)
- if was_empty:
- self.esema.release()
- if not self._full():
- self.fsema.release()
- self.mutex.release()
-
- def put_nowait(self, item):
- """Put an item into the queue without blocking.
-
- Only enqueue the item if a free slot is immediately available.
- Otherwise raise the Full exception.
- """
- return self.put(item, 0)
-
- def get(self, block=1):
- """Remove and return an item from the queue.
-
- If optional arg 'block' is 1 (the default), block if
- necessary until an item is available. Otherwise (block is 0),
- return an item if one is immediately available, else raise the
- Empty exception.
- """
- if block:
- self.esema.acquire()
- elif not self.esema.acquire(0):
- raise Empty
- self.mutex.acquire()
- was_full = self._full()
- item = self._get()
- if was_full:
- self.fsema.release()
- if not self._empty():
- self.esema.release()
- self.mutex.release()
- return item
-
- def get_nowait(self):
- """Remove and return an item from the queue without blocking.
-
- Only get an item if one is immediately available. Otherwise
- raise the Empty exception.
- """
- return self.get(0)
-
- # Override these methods to implement other queue organizations
- # (e.g. stack or priority queue).
- # These will only be called with appropriate locks held
-
- # Initialize the queue representation
- def _init(self, maxsize):
- self.maxsize = maxsize
- self.queue = []
-
- def _qsize(self):
- return len(self.queue)
-
- # Check whether the queue is empty
- def _empty(self):
- return not self.queue
-
- # Check whether the queue is full
- def _full(self):
- return self.maxsize > 0 and len(self.queue) == self.maxsize
-
- # Put a new item in the queue
- def _put(self, item):
- self.queue.append(item)
-
- # Get an item from the queue
- def _get(self):
- item = self.queue[0]
- del self.queue[0]
- return item
diff --git a/Lib/dos-8x3/reconver.py b/Lib/dos-8x3/reconver.py
deleted file mode 100644
index 7c2d376..0000000
--- a/Lib/dos-8x3/reconver.py
+++ /dev/null
@@ -1,186 +0,0 @@
-#! /usr/bin/env python1.5
-
-r"""Convert old ("regex") regular expressions to new syntax ("re").
-
-When imported as a module, there are two functions, with their own
-strings:
-
- convert(s, syntax=None) -- convert a regex regular expression to re syntax
-
- quote(s) -- return a quoted string literal
-
-When used as a script, read a Python string literal (or any other
-expression evaluating to a string) from stdin, and write the
-translated expression to stdout as a string literal. Unless stdout is
-a tty, no trailing \n is written to stdout. This is done so that it
-can be used with Emacs C-U M-| (shell-command-on-region with argument
-which filters the region through the shell command).
-
-No attempt has been made at coding for performance.
-
-Translation table...
-
- \( ( (unless RE_NO_BK_PARENS set)
- \) ) (unless RE_NO_BK_PARENS set)
- \| | (unless RE_NO_BK_VBAR set)
- \< \b (not quite the same, but alla...)
- \> \b (not quite the same, but alla...)
- \` \A
- \' \Z
-
-Not translated...
-
- .
- ^
- $
- *
- + (unless RE_BK_PLUS_QM set, then to \+)
- ? (unless RE_BK_PLUS_QM set, then to \?)
- \
- \b
- \B
- \w
- \W
- \1 ... \9
-
-Special cases...
-
- Non-printable characters are always replaced by their 3-digit
- escape code (except \t, \n, \r, which use mnemonic escapes)
-
- Newline is turned into | when RE_NEWLINE_OR is set
-
-XXX To be done...
-
- [...] (different treatment of backslashed items?)
- [^...] (different treatment of backslashed items?)
- ^ $ * + ? (in some error contexts these are probably treated differently)
- \vDD \DD (in the regex docs but only works when RE_ANSI_HEX set)
-
-"""
-
-
-import regex
-from regex_syntax import * # RE_*
-
-# Default translation table
-mastertable = {
- r'\<': r'\b',
- r'\>': r'\b',
- r'\`': r'\A',
- r'\'': r'\Z',
- r'\(': '(',
- r'\)': ')',
- r'\|': '|',
- '(': r'\(',
- ')': r'\)',
- '|': r'\|',
- '\t': r'\t',
- '\n': r'\n',
- '\r': r'\r',
-}
-
-
-def convert(s, syntax=None):
- """Convert a regex regular expression to re syntax.
-
- The first argument is the regular expression, as a string object,
- just like it would be passed to regex.compile(). (I.e., pass the
- actual string object -- string quotes must already have been
- removed and the standard escape processing has already been done,
- e.g. by eval().)
-
- The optional second argument is the regex syntax variant to be
- used. This is an integer mask as passed to regex.set_syntax();
- the flag bits are defined in regex_syntax. When not specified, or
- when None is given, the current regex syntax mask (as retrieved by
- regex.get_syntax()) is used -- which is 0 by default.
-
- The return value is a regular expression, as a string object that
- could be passed to re.compile(). (I.e., no string quotes have
- been added -- use quote() below, or repr().)
-
- The conversion is not always guaranteed to be correct. More
- syntactical analysis should be performed to detect borderline
- cases and decide what to do with them. For example, 'x*?' is not
- translated correctly.
-
- """
- table = mastertable.copy()
- if syntax is None:
- syntax = regex.get_syntax()
- if syntax & RE_NO_BK_PARENS:
- del table[r'\('], table[r'\)']
- del table['('], table[')']
- if syntax & RE_NO_BK_VBAR:
- del table[r'\|']
- del table['|']
- if syntax & RE_BK_PLUS_QM:
- table['+'] = r'\+'
- table['?'] = r'\?'
- table[r'\+'] = '+'
- table[r'\?'] = '?'
- if syntax & RE_NEWLINE_OR:
- 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
- return res
-
-
-def quote(s, quote=None):
- """Convert a string object to a quoted string literal.
-
- This is similar to repr() but will return a "raw" string (r'...'
- or r"...") when the string contains backslashes, instead of
- doubling all backslashes. The resulting string does *not* always
- evaluate to the same string as the original; however it will do
- just the right thing when passed into re.compile().
-
- The optional second argument forces the string quote; it must be
- a single character which is a valid Python string quote.
-
- """
- if quote is None:
- q = "'"
- altq = "'"
- if q in s and altq not in s:
- q = altq
- else:
- 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
- res = res + q
- if '\\' in res:
- res = 'r' + res
- return res
-
-
-def main():
- """Main program -- called when run as a script."""
- import sys
- s = eval(sys.stdin.read())
- sys.stdout.write(quote(convert(s)))
- if sys.stdout.isatty():
- sys.stdout.write("\n")
-
-
-if __name__ == '__main__':
- main()
diff --git a/Lib/dos-8x3/regex_sy.py b/Lib/dos-8x3/regex_sy.py
deleted file mode 100755
index aab7e7a..0000000
--- a/Lib/dos-8x3/regex_sy.py
+++ /dev/null
@@ -1,53 +0,0 @@
-"""Constants for selecting regexp syntaxes for the obsolete regex module.
-
-This module is only for backward compatibility. "regex" has now
-been replaced by the new regular expression module, "re".
-
-These bits are passed to regex.set_syntax() to choose among
-alternative regexp syntaxes.
-"""
-
-# 1 means plain parentheses serve as grouping, and backslash
-# parentheses are needed for literal searching.
-# 0 means backslash-parentheses are grouping, and plain parentheses
-# are for literal searching.
-RE_NO_BK_PARENS = 1
-
-# 1 means plain | serves as the "or"-operator, and \| is a literal.
-# 0 means \| serves as the "or"-operator, and | is a literal.
-RE_NO_BK_VBAR = 2
-
-# 0 means plain + or ? serves as an operator, and \+, \? are literals.
-# 1 means \+, \? are operators and plain +, ? are literals.
-RE_BK_PLUS_QM = 4
-
-# 1 means | binds tighter than ^ or $.
-# 0 means the contrary.
-RE_TIGHT_VBAR = 8
-
-# 1 means treat \n as an _OR operator
-# 0 means treat it as a normal character
-RE_NEWLINE_OR = 16
-
-# 0 means that a special characters (such as *, ^, and $) always have
-# their special meaning regardless of the surrounding context.
-# 1 means that special characters may act as normal characters in some
-# contexts. Specifically, this applies to:
-# ^ - only special at the beginning, or after ( or |
-# $ - only special at the end, or before ) or |
-# *, +, ? - only special when not after the beginning, (, or |
-RE_CONTEXT_INDEP_OPS = 32
-
-# ANSI sequences (\n etc) and \xhh
-RE_ANSI_HEX = 64
-
-# No GNU extensions
-RE_NO_GNU_EXTENSIONS = 128
-
-# Now define combinations of bits for the standard possibilities.
-RE_SYNTAX_AWK = (RE_NO_BK_PARENS | RE_NO_BK_VBAR | RE_CONTEXT_INDEP_OPS)
-RE_SYNTAX_EGREP = (RE_SYNTAX_AWK | RE_NEWLINE_OR)
-RE_SYNTAX_GREP = (RE_BK_PLUS_QM | RE_NEWLINE_OR)
-RE_SYNTAX_EMACS = 0
-
-# (Python's obsolete "regexp" module used a syntax similar to awk.)
diff --git a/Lib/dos-8x3/regex_te.py b/Lib/dos-8x3/regex_te.py
deleted file mode 100644
index dcb980a..0000000
--- a/Lib/dos-8x3/regex_te.py
+++ /dev/null
@@ -1,289 +0,0 @@
-
-# Regex test suite and benchmark suite v1.5a2
-# Due to the use of r"aw" strings, this file will
-# only work with Python 1.5 or higher.
-
-# The 3 possible outcomes for each pattern
-[SUCCEED, FAIL, SYNTAX_ERROR] = range(3)
-
-# Benchmark suite (needs expansion)
-#
-# The benchmark suite does not test correctness, just speed. The
-# first element of each tuple is the regex pattern; the second is a
-# string to match it against. The benchmarking code will embed the
-# second string inside several sizes of padding, to test how regex
-# matching performs on large strings.
-
-benchmarks = [
- ('Python', 'Python'), # Simple text literal
- ('.*Python', 'Python'), # Bad text literal
- ('.*Python.*', 'Python'), # Worse text literal
- ('.*\\(Python\\)', 'Python'), # Bad text literal with grouping
-
- ('(Python\\|Perl\\|Tcl', 'Perl'), # Alternation
- ('\\(Python\\|Perl\\|Tcl\\)', 'Perl'), # Grouped alternation
- ('\\(Python\\)\\1', 'PythonPython'), # Backreference
-# ('\\([0a-z][a-z]*,\\)+', 'a5,b7,c9,'), # Disable the fastmap optimization
- ('\\([a-z][a-z0-9]*,\\)+', 'a5,b7,c9,') # A few sets
-]
-
-# Test suite (for verifying correctness)
-#
-# The test suite is a list of 5- or 3-tuples. The 5 parts of a
-# complete tuple are:
-# element 0: a string containing the pattern
-# 1: the string to match against the pattern
-# 2: the expected result (SUCCEED, FAIL, SYNTAX_ERROR)
-# 3: a string that will be eval()'ed to produce a test string.
-# This is an arbitrary Python expression; the available
-# variables are "found" (the whole match), and "g1", "g2", ...
-# up to "g10" contain the contents of each group, or the
-# string 'None' if the group wasn't given a value.
-# 4: The expected result of evaluating the expression.
-# If the two don't match, an error is reported.
-#
-# If the regex isn't expected to work, the latter two elements can be omitted.
-
-tests = [
-('abc', 'abc', SUCCEED,
- 'found', 'abc'),
-('abc', 'xbc', FAIL),
-('abc', 'axc', FAIL),
-('abc', 'abx', FAIL),
-('abc', 'xabcy', SUCCEED,
- 'found', 'abc'),
-('abc', 'ababc', SUCCEED,
- 'found', 'abc'),
-('ab*c', 'abc', SUCCEED,
- 'found', 'abc'),
-('ab*bc', 'abc', SUCCEED,
- 'found', 'abc'),
-('ab*bc', 'abbc', SUCCEED,
- 'found', 'abbc'),
-('ab*bc', 'abbbbc', SUCCEED,
- 'found', 'abbbbc'),
-('ab+bc', 'abbc', SUCCEED,
- 'found', 'abbc'),
-('ab+bc', 'abc', FAIL),
-('ab+bc', 'abq', FAIL),
-('ab+bc', 'abbbbc', SUCCEED,
- 'found', 'abbbbc'),
-('ab?bc', 'abbc', SUCCEED,
- 'found', 'abbc'),
-('ab?bc', 'abc', SUCCEED,
- 'found', 'abc'),
-('ab?bc', 'abbbbc', FAIL),
-('ab?c', 'abc', SUCCEED,
- 'found', 'abc'),
-('^abc$', 'abc', SUCCEED,
- 'found', 'abc'),
-('^abc$', 'abcc', FAIL),
-('^abc', 'abcc', SUCCEED,
- 'found', 'abc'),
-('^abc$', 'aabc', FAIL),
-('abc$', 'aabc', SUCCEED,
- 'found', 'abc'),
-('^', 'abc', SUCCEED,
- 'found+"-"', '-'),
-('$', 'abc', SUCCEED,
- 'found+"-"', '-'),
-('a.c', 'abc', SUCCEED,
- 'found', 'abc'),
-('a.c', 'axc', SUCCEED,
- 'found', 'axc'),
-('a.*c', 'axyzc', SUCCEED,
- 'found', 'axyzc'),
-('a.*c', 'axyzd', FAIL),
-('a[bc]d', 'abc', FAIL),
-('a[bc]d', 'abd', SUCCEED,
- 'found', 'abd'),
-('a[b-d]e', 'abd', FAIL),
-('a[b-d]e', 'ace', SUCCEED,
- 'found', 'ace'),
-('a[b-d]', 'aac', SUCCEED,
- 'found', 'ac'),
-('a[-b]', 'a-', SUCCEED,
- 'found', 'a-'),
-('a[b-]', 'a-', SUCCEED,
- 'found', 'a-'),
-('a[]b', '-', SYNTAX_ERROR),
-('a[', '-', SYNTAX_ERROR),
-('a\\', '-', SYNTAX_ERROR),
-('abc\\)', '-', SYNTAX_ERROR),
-('\\(abc', '-', SYNTAX_ERROR),
-('a]', 'a]', SUCCEED,
- 'found', 'a]'),
-('a[]]b', 'a]b', SUCCEED,
- 'found', 'a]b'),
-('a[^bc]d', 'aed', SUCCEED,
- 'found', 'aed'),
-('a[^bc]d', 'abd', FAIL),
-('a[^-b]c', 'adc', SUCCEED,
- 'found', 'adc'),
-('a[^-b]c', 'a-c', FAIL),
-('a[^]b]c', 'a]c', FAIL),
-('a[^]b]c', 'adc', SUCCEED,
- 'found', 'adc'),
-('\\ba\\b', 'a-', SUCCEED,
- '"-"', '-'),
-('\\ba\\b', '-a', SUCCEED,
- '"-"', '-'),
-('\\ba\\b', '-a-', SUCCEED,
- '"-"', '-'),
-('\\by\\b', 'xy', FAIL),
-('\\by\\b', 'yz', FAIL),
-('\\by\\b', 'xyz', FAIL),
-('ab\\|cd', 'abc', SUCCEED,
- 'found', 'ab'),
-('ab\\|cd', 'abcd', SUCCEED,
- 'found', 'ab'),
-('\\(\\)ef', 'def', SUCCEED,
- 'found+"-"+g1', 'ef-'),
-('$b', 'b', FAIL),
-('a(b', 'a(b', SUCCEED,
- 'found+"-"+g1', 'a(b-None'),
-('a(*b', 'ab', SUCCEED,
- 'found', 'ab'),
-('a(*b', 'a((b', SUCCEED,
- 'found', 'a((b'),
-('a\\\\b', 'a\\b', SUCCEED,
- 'found', 'a\\b'),
-('\\(\\(a\\)\\)', 'abc', SUCCEED,
- 'found+"-"+g1+"-"+g2', 'a-a-a'),
-('\\(a\\)b\\(c\\)', 'abc', SUCCEED,
- 'found+"-"+g1+"-"+g2', 'abc-a-c'),
-('a+b+c', 'aabbabc', SUCCEED,
- 'found', 'abc'),
-('\\(a+\\|b\\)*', 'ab', SUCCEED,
- 'found+"-"+g1', 'ab-b'),
-('\\(a+\\|b\\)+', 'ab', SUCCEED,
- 'found+"-"+g1', 'ab-b'),
-('\\(a+\\|b\\)?', 'ab', SUCCEED,
- 'found+"-"+g1', 'a-a'),
-('\\)\\(', '-', SYNTAX_ERROR),
-('[^ab]*', 'cde', SUCCEED,
- 'found', 'cde'),
-('abc', '', FAIL),
-('a*', '', SUCCEED,
- 'found', ''),
-('a\\|b\\|c\\|d\\|e', 'e', SUCCEED,
- 'found', 'e'),
-('\\(a\\|b\\|c\\|d\\|e\\)f', 'ef', SUCCEED,
- 'found+"-"+g1', 'ef-e'),
-('abcd*efg', 'abcdefg', SUCCEED,
- 'found', 'abcdefg'),
-('ab*', 'xabyabbbz', SUCCEED,
- 'found', 'ab'),
-('ab*', 'xayabbbz', SUCCEED,
- 'found', 'a'),
-('\\(ab\\|cd\\)e', 'abcde', SUCCEED,
- 'found+"-"+g1', 'cde-cd'),
-('[abhgefdc]ij', 'hij', SUCCEED,
- 'found', 'hij'),
-('^\\(ab\\|cd\\)e', 'abcde', FAIL,
- 'xg1y', 'xy'),
-('\\(abc\\|\\)ef', 'abcdef', SUCCEED,
- 'found+"-"+g1', 'ef-'),
-('\\(a\\|b\\)c*d', 'abcd', SUCCEED,
- 'found+"-"+g1', 'bcd-b'),
-('\\(ab\\|ab*\\)bc', 'abc', SUCCEED,
- 'found+"-"+g1', 'abc-a'),
-('a\\([bc]*\\)c*', 'abc', SUCCEED,
- 'found+"-"+g1', 'abc-bc'),
-('a\\([bc]*\\)\\(c*d\\)', 'abcd', SUCCEED,
- 'found+"-"+g1+"-"+g2', 'abcd-bc-d'),
-('a\\([bc]+\\)\\(c*d\\)', 'abcd', SUCCEED,
- 'found+"-"+g1+"-"+g2', 'abcd-bc-d'),
-('a\\([bc]*\\)\\(c+d\\)', 'abcd', SUCCEED,
- 'found+"-"+g1+"-"+g2', 'abcd-b-cd'),
-('a[bcd]*dcdcde', 'adcdcde', SUCCEED,
- 'found', 'adcdcde'),
-('a[bcd]+dcdcde', 'adcdcde', FAIL),
-('\\(ab\\|a\\)b*c', 'abc', SUCCEED,
- 'found+"-"+g1', 'abc-ab'),
-('\\(\\(a\\)\\(b\\)c\\)\\(d\\)', 'abcd', SUCCEED,
- 'g1+"-"+g2+"-"+g3+"-"+g4', 'abc-a-b-d'),
-('[a-zA-Z_][a-zA-Z0-9_]*', 'alpha', SUCCEED,
- 'found', 'alpha'),
-('^a\\(bc+\\|b[eh]\\)g\\|.h$', 'abh', SUCCEED,
- 'found+"-"+g1', 'bh-None'),
-('\\(bc+d$\\|ef*g.\\|h?i\\(j\\|k\\)\\)', 'effgz', SUCCEED,
- 'found+"-"+g1+"-"+g2', 'effgz-effgz-None'),
-('\\(bc+d$\\|ef*g.\\|h?i\\(j\\|k\\)\\)', 'ij', SUCCEED,
- 'found+"-"+g1+"-"+g2', 'ij-ij-j'),
-('\\(bc+d$\\|ef*g.\\|h?i\\(j\\|k\\)\\)', 'effg', FAIL),
-('\\(bc+d$\\|ef*g.\\|h?i\\(j\\|k\\)\\)', 'bcdd', FAIL),
-('\\(bc+d$\\|ef*g.\\|h?i\\(j\\|k\\)\\)', 'reffgz', SUCCEED,
- 'found+"-"+g1+"-"+g2', 'effgz-effgz-None'),
-('\\(\\(\\(\\(\\(\\(\\(\\(\\(a\\)\\)\\)\\)\\)\\)\\)\\)\\)', 'a', SUCCEED,
- 'found', 'a'),
-('multiple words of text', 'uh-uh', FAIL),
-('multiple words', 'multiple words, yeah', SUCCEED,
- 'found', 'multiple words'),
-('\\(.*\\)c\\(.*\\)', 'abcde', SUCCEED,
- 'found+"-"+g1+"-"+g2', 'abcde-ab-de'),
-('(\\(.*\\), \\(.*\\))', '(a, b)', SUCCEED,
- 'g2+"-"+g1', 'b-a'),
-('[k]', 'ab', FAIL),
-('a[-]?c', 'ac', SUCCEED,
- 'found', 'ac'),
-('\\(abc\\)\\1', 'abcabc', SUCCEED,
- 'g1', 'abc'),
-('\\([a-c]*\\)\\1', 'abcabc', SUCCEED,
- 'g1', 'abc'),
-('^\\(.+\\)?B', 'AB', SUCCEED,
- 'g1', 'A'),
-('\\(a+\\).\\1$', 'aaaaa', SUCCEED,
- 'found+"-"+g1', 'aaaaa-aa'),
-('^\\(a+\\).\\1$', 'aaaa', FAIL),
-('\\(abc\\)\\1', 'abcabc', SUCCEED,
- 'found+"-"+g1', 'abcabc-abc'),
-('\\([a-c]+\\)\\1', 'abcabc', SUCCEED,
- 'found+"-"+g1', 'abcabc-abc'),
-('\\(a\\)\\1', 'aa', SUCCEED,
- 'found+"-"+g1', 'aa-a'),
-('\\(a+\\)\\1', 'aa', SUCCEED,
- 'found+"-"+g1', 'aa-a'),
-('\\(a+\\)+\\1', 'aa', SUCCEED,
- 'found+"-"+g1', 'aa-a'),
-('\\(a\\).+\\1', 'aba', SUCCEED,
- 'found+"-"+g1', 'aba-a'),
-('\\(a\\)ba*\\1', 'aba', SUCCEED,
- 'found+"-"+g1', 'aba-a'),
-('\\(aa\\|a\\)a\\1$', 'aaa', SUCCEED,
- 'found+"-"+g1', 'aaa-a'),
-('\\(a\\|aa\\)a\\1$', 'aaa', SUCCEED,
- 'found+"-"+g1', 'aaa-a'),
-('\\(a+\\)a\\1$', 'aaa', SUCCEED,
- 'found+"-"+g1', 'aaa-a'),
-('\\([abc]*\\)\\1', 'abcabc', SUCCEED,
- 'found+"-"+g1', 'abcabc-abc'),
-('\\(a\\)\\(b\\)c\\|ab', 'ab', SUCCEED,
- 'found+"-"+g1+"-"+g2', 'ab-None-None'),
-('\\(a\\)+x', 'aaax', SUCCEED,
- 'found+"-"+g1', 'aaax-a'),
-('\\([ac]\\)+x', 'aacx', SUCCEED,
- 'found+"-"+g1', 'aacx-c'),
-('\\([^/]*/\\)*sub1/', 'd:msgs/tdir/sub1/trial/away.cpp', SUCCEED,
- 'found+"-"+g1', 'd:msgs/tdir/sub1/-tdir/'),
-('\\([^.]*\\)\\.\\([^:]*\\):[T ]+\\(.*\\)', 'track1.title:TBlah blah blah', SUCCEED,
- 'found+"-"+g1+"-"+g2+"-"+g3', 'track1.title:TBlah blah blah-track1-title-Blah blah blah'),
-('\\([^N]*N\\)+', 'abNNxyzN', SUCCEED,
- 'found+"-"+g1', 'abNNxyzN-xyzN'),
-('\\([^N]*N\\)+', 'abNNxyz', SUCCEED,
- 'found+"-"+g1', 'abNN-N'),
-('\\([abc]*\\)x', 'abcx', SUCCEED,
- 'found+"-"+g1', 'abcx-abc'),
-('\\([abc]*\\)x', 'abc', FAIL),
-('\\([xyz]*\\)x', 'abcx', SUCCEED,
- 'found+"-"+g1', 'x-'),
-('\\(a\\)+b\\|aac', 'aac', SUCCEED,
- 'found+"-"+g1', 'aac-None'),
-('\<a', 'a', SUCCEED, 'found', 'a'),
-('\<a', '!', FAIL),
-('a\<b', 'ab', FAIL),
-('a\>', 'ab', FAIL),
-('a\>', 'a!', SUCCEED, 'found', 'a'),
-('a\>', 'a', SUCCEED, 'found', 'a'),
-]
-
diff --git a/Lib/dos-8x3/rlcomple.py b/Lib/dos-8x3/rlcomple.py
deleted file mode 100644
index 8cd21ed..0000000
--- a/Lib/dos-8x3/rlcomple.py
+++ /dev/null
@@ -1,120 +0,0 @@
-"""Word completion for GNU readline 2.0.
-
-This requires the latest extension to the readline module (the
-completes keywords, built-ins and globals in __main__; when completing
-NAME.NAME..., it evaluates (!) the expression up to the last dot and
-completes its attributes.
-
-It's very cool to do "import string" type "string.", hit the
-completion key (twice), and see the list of names defined by the
-string module!
-
-Tip: to use the tab key as the completion key, call
-
- readline.parse_and_bind("tab: complete")
-
-Notes:
-
-- Exceptions raised by the completer function are *ignored* (and
-generally cause the completion to fail). This is a feature -- since
-readline sets the tty device in raw (or cbreak) mode, printing a
-traceback wouldn't work well without some complicated hoopla to save,
-reset and restore the tty state.
-
-- The evaluation of the NAME.NAME... form may cause arbitrary
-application defined code to be executed if an object with a
-__getattr__ hook is found. Since it is the responsibility of the
-application (or the user) to enable this feature, I consider this an
-acceptable risk. More complicated expressions (e.g. function calls or
-indexing operations) are *not* evaluated.
-
-- GNU readline is also used by the built-in functions input() and
-raw_input(), and thus these also benefit/suffer from the completer
-features. Clearly an interactive application can benefit by
-specifying its own completer function and using raw_input() for all
-its input.
-
-- When the original stdin is not a tty device, GNU readline is never
-used, and this module (and the readline module) are silently inactive.
-
-"""
-
-import readline
-import __builtin__
-import __main__
-
-class Completer:
-
- def complete(self, text, state):
- """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'.
-
- """
- if state == 0:
- if "." in text:
- self.matches = self.attr_matches(text)
- else:
- self.matches = self.global_matches(text)
- try:
- return self.matches[state]
- except IndexError:
- return None
-
- 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 and word != "__builtins__":
- 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
- evaluatable in the globals of __main__, it will be evaluated
- and its attributes (as revealed by dir()) are used as possible
- completions. (For class instances, class members are are also
- considered.)
-
- 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)
- object = eval(expr, __main__.__dict__)
- words = dir(object)
- if hasattr(object,'__class__'):
- words.append('__class__')
- words = words + get_class_members(object.__class__)
- matches = []
- n = len(attr)
- for word in words:
- if word[:n] == attr and word != "__builtins__":
- matches.append("%s.%s" % (expr, word))
- return matches
-
-def get_class_members(klass):
- ret = dir(klass)
- if hasattr(klass,'__bases__'):
- for base in klass.__bases__:
- ret = ret + get_class_members(base)
- return ret
-
-readline.set_completer(Completer().complete)
diff --git a/Lib/dos-8x3/robotpar.py b/Lib/dos-8x3/robotpar.py
deleted file mode 100644
index 3f4396b..0000000
--- a/Lib/dos-8x3/robotpar.py
+++ /dev/null
@@ -1,97 +0,0 @@
-"""
-
-Robots.txt file parser class. Accepts a list of lines or robots.txt URL as
-input, builds a set of rules from that list, then answers questions about
-fetchability of other URLs.
-
-"""
-
-class RobotFileParser:
-
- def __init__(self):
- self.rules = {}
- self.debug = 0
- self.url = ''
- self.last_checked = 0
-
- def mtime(self):
- return self.last_checked
-
- def modified(self):
- import time
- self.last_checked = time.time()
-
- def set_url(self, url):
- self.url = url
-
- def read(self):
- import urllib
- self.parse(urllib.urlopen(self.url).readlines())
-
- def parse(self, lines):
- """parse the input lines from a robot.txt file"""
- import string, re
- active = []
- for line in lines:
- if self.debug: print '>', line,
- # blank line terminates current record
- if not line[:-1]:
- active = []
- continue
- # remove optional comment and strip line
- line = string.strip(line[:string.find(line, '#')])
- if not line:
- continue
- line = re.split(' *: *', line)
- if len(line) == 2:
- line[0] = string.lower(line[0])
- if line[0] == 'user-agent':
- # this record applies to this user agent
- if self.debug: print '>> user-agent:', line[1]
- active.append(line[1])
- if not self.rules.has_key(line[1]):
- self.rules[line[1]] = []
- elif line[0] == 'disallow':
- if line[1]:
- if self.debug: print '>> disallow:', line[1]
- for agent in active:
- self.rules[agent].append(re.compile(line[1]))
- else:
- pass
- for agent in active:
- if self.debug: print '>> allow', agent
- self.rules[agent] = []
- else:
- if self.debug: print '>> unknown:', line
-
- self.modified()
-
- # returns true if agent is allowed to fetch url
- def can_fetch(self, useragent, url):
- """using the parsed robots.txt decide if useragent can fetch url"""
- import urlparse
- ag = useragent
- if not self.rules.has_key(ag): ag = '*'
- if not self.rules.has_key(ag):
- if self.debug: print '>> allowing', url, 'fetch by', useragent
- return 1
- path = urlparse.urlparse(url)[2]
- for rule in self.rules[ag]:
- if rule.match(path) is not None:
- if self.debug: print '>> disallowing', url, 'fetch by', useragent
- return 0
- if self.debug: print '>> allowing', url, 'fetch by', useragent
- return 1
-
-def _test():
- rp = RobotFileParser()
- rp.debug = 1
- rp.set_url('http://www.musi-cal.com/robots.txt')
- rp.read()
- print rp.rules
- print rp.can_fetch('*', 'http://www.musi-cal.com.com/')
- print rp.can_fetch('Musi-Cal-Robot',
- 'http://www.musi-cal.com/cgi-bin/event-search?city=San+Francisco')
-
-if __name__ == "__main__":
- _test()
diff --git a/Lib/dos-8x3/simpleht.py b/Lib/dos-8x3/simpleht.py
deleted file mode 100755
index 4cfedbc..0000000
--- a/Lib/dos-8x3/simpleht.py
+++ /dev/null
@@ -1,198 +0,0 @@
-"""Simple HTTP Server.
-
-This module builds on BaseHTTPServer by implementing the standard GET
-and HEAD requests in a fairly straightforward manner.
-
-"""
-
-
-__version__ = "0.5"
-
-
-import os
-import string
-import posixpath
-import BaseHTTPServer
-import urllib
-import cgi
-import shutil
-from StringIO import StringIO
-
-
-class SimpleHTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
-
- """Simple HTTP request handler with GET and HEAD commands.
-
- This serves files from the current directory and any of its
- subdirectories. It assumes that all files are plain text files
- unless they have the extension ".html" in which case it assumes
- they are HTML files.
-
- The GET and HEAD requests are identical except that the HEAD
- request omits the actual contents of the file.
-
- """
-
- server_version = "SimpleHTTP/" + __version__
-
- def do_GET(self):
- """Serve a GET request."""
- f = self.send_head()
- if f:
- self.copyfile(f, self.wfile)
- f.close()
-
- def do_HEAD(self):
- """Serve a HEAD request."""
- f = self.send_head()
- if f:
- f.close()
-
- def send_head(self):
- """Common code for GET and HEAD commands.
-
- This sends the response code and MIME headers.
-
- Return value is either a file object (which has to be copied
- to the outputfile by the caller unless the command was HEAD,
- and must be closed by the caller under all circumstances), or
- None, in which case the caller has nothing further to do.
-
- """
- path = self.translate_path(self.path)
- f = None
- if os.path.isdir(path):
- for index in "index.html", "index.htm":
- index = os.path.join(path, index)
- if os.path.exists(index):
- path = index
- break
- else:
- return self.list_directory(path)
- ctype = self.guess_type(path)
- if ctype.startswith('text/'):
- mode = 'r'
- else:
- mode = 'rb'
- try:
- f = open(path, mode)
- except IOError:
- self.send_error(404, "File not found")
- return None
- self.send_response(200)
- self.send_header("Content-type", ctype)
- self.end_headers()
- return f
-
- def list_directory(self, path):
- """Helper to produce a directory listing (absent index.html).
-
- Return value is either a file object, or None (indicating an
- error). In either case, the headers are sent, making the
- interface the same as for send_head().
-
- """
- try:
- list = os.listdir(path)
- except os.error:
- self.send_error(404, "No permission to list directory");
- return None
- list.sort(lambda a, b: cmp(a.lower(), b.lower()))
- f = StringIO()
- f.write("<title>Directory listing for %s</title>\n" % self.path)
- f.write("<h2>Directory listing for %s</h2>\n" % self.path)
- f.write("<hr>\n<ul>\n")
- for name in list:
- fullname = os.path.join(path, name)
- displayname = linkname = name = cgi.escape(name)
- # Append / for directories or @ for symbolic links
- if os.path.isdir(fullname):
- displayname = name + "/"
- linkname = name + "/"
- if os.path.islink(fullname):
- displayname = name + "@"
- # Note: a link to a directory displays with @ and links with /
- f.write('<li><a href="%s">%s</a>\n' % (linkname, displayname))
- f.write("</ul>\n<hr>\n")
- f.seek(0)
- self.send_response(200)
- self.send_header("Content-type", "text/html")
- 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(urllib.unquote(path))
- words = string.splitfields(path, '/')
- words = filter(None, words)
- path = os.getcwd()
- for word in words:
- drive, word = os.path.splitdrive(word)
- head, word = os.path.split(word)
- if word in (os.curdir, os.pardir): continue
- path = os.path.join(path, word)
- return path
-
- def copyfile(self, source, outputfile):
- """Copy all data between two file objects.
-
- The SOURCE argument is a file object open for reading
- (or anything with a read() method) and the DESTINATION
- argument is a file object open for writing (or
- anything with a write() method).
-
- The only reason for overriding this would be to change
- the block size or perhaps to replace newlines by CRLF
- -- note however that this the default server uses this
- to copy binary data as well.
-
- """
- shutil.copyfileobj(source, outputfile)
-
- def guess_type(self, path):
- """Guess the type of a file.
-
- Argument is a PATH (a filename).
-
- Return value is a string of the form type/subtype,
- usable for a MIME Content-type header.
-
- The default implementation looks the file's extension
- up in the table self.extensions_map, using text/plain
- as a default; however it would be permissible (if
- slow) to look inside the data to make a better guess.
-
- """
-
- base, ext = posixpath.splitext(path)
- if self.extensions_map.has_key(ext):
- return self.extensions_map[ext]
- ext = string.lower(ext)
- if self.extensions_map.has_key(ext):
- return self.extensions_map[ext]
- else:
- return self.extensions_map['']
-
- extensions_map = {
- '': 'text/plain', # Default, *must* be present
- '.html': 'text/html',
- '.htm': 'text/html',
- '.gif': 'image/gif',
- '.jpg': 'image/jpeg',
- '.jpeg': 'image/jpeg',
- }
-
-
-def test(HandlerClass = SimpleHTTPRequestHandler,
- ServerClass = BaseHTTPServer.HTTPServer):
- BaseHTTPServer.test(HandlerClass, ServerClass)
-
-
-if __name__ == '__main__':
- test()
diff --git a/Lib/dos-8x3/socketse.py b/Lib/dos-8x3/socketse.py
deleted file mode 100755
index a263f8e..0000000
--- a/Lib/dos-8x3/socketse.py
+++ /dev/null
@@ -1,447 +0,0 @@
-"""Generic socket server classes.
-
-This module tries to capture the various aspects of defining a server:
-
-- address family:
- - AF_INET: IP (Internet Protocol) sockets (default)
- - AF_UNIX: Unix domain sockets
- - others, e.g. AF_DECNET are conceivable (see <socket.h>
-- socket type:
- - SOCK_STREAM (reliable stream, e.g. TCP)
- - SOCK_DGRAM (datagrams, e.g. UDP)
-- client address verification before further looking at the request
- (This is actually a hook for any processing that needs to look
- at the request before anything else, e.g. logging)
-- how to handle multiple requests:
- - synchronous (one request is handled at a time)
- - forking (each request is handled by a new process)
- - threading (each request is handled by a new thread)
-
-The classes in this module favor the server type that is simplest to
-write: a synchronous TCP/IP server. This is bad class design, but
-save some typing. (There's also the issue that a deep class hierarchy
-slows down method lookups.)
-
-There are four classes in an inheritance diagram that represent
-synchronous servers of four types:
-
- +-----------+ +------------------+
- | TCPServer |------->| UnixStreamServer |
- +-----------+ +------------------+
- |
- v
- +-----------+ +--------------------+
- | UDPServer |------->| UnixDatagramServer |
- +-----------+ +--------------------+
-
-Note that UnixDatagramServer derives from UDPServer, not from
-UnixStreamServer -- the only difference between an IP and a Unix
-stream server is the address family, which is simply repeated in both
-unix server classes.
-
-Forking and threading versions of each type of server can be created
-using the ForkingServer and ThreadingServer mix-in classes. For
-instance, a threading UDP server class is created as follows:
-
- class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass
-
-The Mix-in class must come first, since it overrides a method defined
-in UDPServer!
-
-To implement a service, you must derive a class from
-BaseRequestHandler and redefine its handle() method. You can then run
-various versions of the service by combining one of the server classes
-with your request handler class.
-
-The request handler class must be different for datagram or stream
-services. This can be hidden by using the mix-in request handler
-classes StreamRequestHandler or DatagramRequestHandler.
-
-Of course, you still have to use your head!
-
-For instance, it makes no sense to use a forking server if the service
-contains state in memory that can be modified by requests (since the
-modifications in the child process would never reach the initial state
-kept in the parent process and passed to each child). In this case,
-you can use a threading server, but you will probably have to use
-locks to avoid two requests that come in nearly simultaneous to apply
-conflicting changes to the server state.
-
-On the other hand, if you are building e.g. an HTTP server, where all
-data is stored externally (e.g. in the file system), a synchronous
-class will essentially render the service "deaf" while one request is
-being handled -- which may be for a very long time if a client is slow
-to reqd all the data it has requested. Here a threading or forking
-server is appropriate.
-
-In some cases, it may be appropriate to process part of a request
-synchronously, but to finish processing in a forked child depending on
-the request data. This can be implemented by using a synchronous
-server and doing an explicit fork in the request handler class's
-handle() method.
-
-Another approach to handling multiple simultaneous requests in an
-environment that supports neither threads nor fork (or where these are
-too expensive or inappropriate for the service) is to maintain an
-explicit table of partially finished requests and to use select() to
-decide which request to work on next (or whether to handle a new
-incoming request). This is particularly important for stream services
-where each client can potentially be connected for a long time (if
-threads or subprocesses can't be used).
-
-Future work:
-- Standard classes for Sun RPC (which uses either UDP or TCP)
-- Standard mix-in classes to implement various authentication
- and encryption schemes
-- Standard framework for select-based multiplexing
-
-XXX Open problems:
-- What to do with out-of-band data?
-
-"""
-
-
-__version__ = "0.2"
-
-
-import socket
-import sys
-import os
-
-
-class TCPServer:
-
- """Base class for various socket-based server classes.
-
- Defaults to synchronous IP stream (i.e., TCP).
-
- Methods for the caller:
-
- - __init__(server_address, RequestHandlerClass)
- - serve_forever()
- - handle_request() # if you don't use serve_forever()
- - fileno() -> int # for select()
-
- Methods that may be overridden:
-
- - server_bind()
- - server_activate()
- - get_request() -> request, client_address
- - verify_request(request, client_address)
- - process_request(request, client_address)
- - handle_error()
-
- Methods for derived classes:
-
- - finish_request(request, client_address)
-
- Class variables that may be overridden by derived classes or
- instances:
-
- - address_family
- - socket_type
- - request_queue_size (only for stream sockets)
- - reuse_address
-
- Instance variables:
-
- - server_address
- - RequestHandlerClass
- - socket
-
- """
-
- address_family = socket.AF_INET
-
- socket_type = socket.SOCK_STREAM
-
- request_queue_size = 5
-
- allow_reuse_address = 0
-
- def __init__(self, server_address, RequestHandlerClass):
- """Constructor. May be extended, do not override."""
- self.server_address = server_address
- self.RequestHandlerClass = RequestHandlerClass
- self.socket = socket.socket(self.address_family,
- self.socket_type)
- self.server_bind()
- self.server_activate()
-
- def server_bind(self):
- """Called by constructor to bind the socket.
-
- May be overridden.
-
- """
- if self.allow_reuse_address:
- self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
- self.socket.bind(self.server_address)
-
- def server_activate(self):
- """Called by constructor to activate the server.
-
- May be overridden.
-
- """
- self.socket.listen(self.request_queue_size)
-
- def fileno(self):
- """Return socket file number.
-
- Interface required by select().
-
- """
- return self.socket.fileno()
-
- def serve_forever(self):
- """Handle one request at a time until doomsday."""
- while 1:
- self.handle_request()
-
- # The distinction between handling, getting, processing and
- # finishing a request is fairly arbitrary. Remember:
- #
- # - handle_request() is the top-level call. It calls
- # get_request(), verify_request() and process_request()
- # - get_request() is different for stream or datagram sockets
- # - process_request() is the place that may fork a new process
- # or create a new thread to finish the request
- # - finish_request() instantiates the request handler class;
- # this constructor will handle the request all by itself
-
- def handle_request(self):
- """Handle one request, possibly blocking."""
- try:
- request, client_address = self.get_request()
- except socket.error:
- return
- if self.verify_request(request, client_address):
- try:
- self.process_request(request, client_address)
- except:
- self.handle_error(request, client_address)
-
- def get_request(self):
- """Get the request and client address from the socket.
-
- May be overridden.
-
- """
- return self.socket.accept()
-
- def verify_request(self, request, client_address):
- """Verify the request. May be overridden.
-
- Return true if we should proceed with this request.
-
- """
- return 1
-
- def process_request(self, request, client_address):
- """Call finish_request.
-
- Overridden by ForkingMixIn and ThreadingMixIn.
-
- """
- self.finish_request(request, client_address)
-
- def finish_request(self, request, client_address):
- """Finish one request by instantiating RequestHandlerClass."""
- self.RequestHandlerClass(request, client_address, self)
-
- def handle_error(self, request, client_address):
- """Handle an error gracefully. May be overridden.
-
- The default is to print a traceback and continue.
-
- """
- print '-'*40
- print 'Exception happened during processing of request from',
- print client_address
- import traceback
- traceback.print_exc()
- print '-'*40
-
-
-class UDPServer(TCPServer):
-
- """UDP server class."""
-
- socket_type = socket.SOCK_DGRAM
-
- max_packet_size = 8192
-
- def get_request(self):
- data, client_addr = self.socket.recvfrom(self.max_packet_size)
- return (data, self.socket), client_addr
-
- def server_activate(self):
- # No need to call listen() for UDP.
- pass
-
-
-class ForkingMixIn:
-
- """Mix-in class to handle each request in a new process."""
-
- active_children = None
- max_children = 40
-
- def collect_children(self):
- """Internal routine to wait for died children."""
- while self.active_children:
- if len(self.active_children) < self.max_children:
- options = os.WNOHANG
- else:
- # If the maximum number of children are already
- # running, block while waiting for a child to exit
- options = 0
- try:
- pid, status = os.waitpid(0, options)
- except os.error:
- pid = None
- 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.socket.close()
- self.finish_request(request, client_address)
- os._exit(0)
- except:
- try:
- self.handle_error(request,
- client_address)
- finally:
- os._exit(1)
-
-
-class ThreadingMixIn:
- """Mix-in class to handle each request in a new thread."""
-
- def process_request(self, request, client_address):
- """Start a new thread to process the request."""
- import threading
- t = threading.Thread(target = self.finish_request,
- args = (request, client_address))
- t.start()
-
-
-class ForkingUDPServer(ForkingMixIn, UDPServer): pass
-class ForkingTCPServer(ForkingMixIn, TCPServer): pass
-
-class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass
-class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass
-
-if hasattr(socket, 'AF_UNIX'):
-
- class UnixStreamServer(TCPServer):
- address_family = socket.AF_UNIX
-
- class UnixDatagramServer(UDPServer):
- address_family = socket.AF_UNIX
-
- class ThreadingUnixStreamServer(ThreadingMixIn, UnixStreamServer): pass
-
- class ThreadingUnixDatagramServer(ThreadingMixIn, UnixDatagramServer): pass
-
-class BaseRequestHandler:
-
- """Base class for request handler classes.
-
- This class is instantiated for each request to be handled. The
- constructor sets the instance variables request, client_address
- and server, and then calls the handle() method. To implement a
- specific service, all you need to do is to derive a class which
- defines a handle() method.
-
- The handle() method can find the request as self.request, the
- client address as self.client_address, and the server (in case it
- needs access to per-server information) as self.server. Since a
- separate instance is created for each request, the handle() method
- can define arbitrary other instance variariables.
-
- """
-
- def __init__(self, request, client_address, server):
- self.request = request
- self.client_address = client_address
- self.server = server
- try:
- self.setup()
- self.handle()
- self.finish()
- finally:
- sys.exc_traceback = None # Help garbage collection
-
- def setup(self):
- pass
-
- def __del__(self):
- pass
-
- def handle(self):
- pass
-
- def finish(self):
- pass
-
-
-# The following two classes make it possible to use the same service
-# class for stream or datagram servers.
-# Each class sets up these instance variables:
-# - rfile: a file object from which receives the request is read
-# - wfile: a file object to which the reply is written
-# When the handle() method returns, wfile is flushed properly
-
-
-class StreamRequestHandler(BaseRequestHandler):
-
- """Define self.rfile and self.wfile for stream sockets."""
-
- # Default buffer sizes for rfile, wfile.
- # We default rfile to buffered because otherwise it could be
- # really slow for large data (a getc() call per byte); we make
- # wfile unbuffered because (a) often after a write() we want to
- # read and we need to flush the line; (b) big writes to unbuffered
- # files are typically optimized by stdio even when big reads
- # aren't.
- rbufsize = -1
- wbufsize = 0
-
- def setup(self):
- self.connection = self.request
- self.rfile = self.connection.makefile('rb', self.rbufsize)
- self.wfile = self.connection.makefile('wb', self.wbufsize)
-
- def finish(self):
- self.wfile.flush()
- self.wfile.close()
- self.rfile.close()
-
-
-class DatagramRequestHandler(BaseRequestHandler):
-
- """Define self.rfile and self.wfile for datagram sockets."""
-
- def setup(self):
- import StringIO
- self.packet, self.socket = self.request
- self.rfile = StringIO.StringIO(self.packet)
- self.wfile = StringIO.StringIO(self.packet)
-
- def finish(self):
- self.socket.sendto(self.wfile.getvalue(), self.client_address)
diff --git a/Lib/dos-8x3/sre_comp.py b/Lib/dos-8x3/sre_comp.py
deleted file mode 100644
index dc508e5..0000000
--- a/Lib/dos-8x3/sre_comp.py
+++ /dev/null
@@ -1,381 +0,0 @@
-#
-# Secret Labs' Regular Expression Engine
-#
-# convert template to internal format
-#
-# Copyright (c) 1997-2000 by Secret Labs AB. All rights reserved.
-#
-# See the sre.py file for information on usage and redistribution.
-#
-
-import _sre
-
-from sre_constants import *
-
-MAXCODE = 65535
-
-def _compile(code, pattern, flags):
- # internal: compile a (sub)pattern
- emit = code.append
- for op, av in pattern:
- if op in (LITERAL, NOT_LITERAL):
- if flags & SRE_FLAG_IGNORECASE:
- emit(OPCODES[OP_IGNORE[op]])
- else:
- emit(OPCODES[op])
- emit(av)
- elif op is IN:
- if flags & SRE_FLAG_IGNORECASE:
- emit(OPCODES[OP_IGNORE[op]])
- def fixup(literal, flags=flags):
- return _sre.getlower(literal, flags)
- else:
- emit(OPCODES[op])
- fixup = lambda x: x
- skip = len(code); emit(0)
- _compile_charset(av, flags, code, fixup)
- code[skip] = len(code) - skip
- elif op is ANY:
- if flags & SRE_FLAG_DOTALL:
- emit(OPCODES[ANY_ALL])
- else:
- emit(OPCODES[ANY])
- elif op in (REPEAT, MIN_REPEAT, MAX_REPEAT):
- if flags & SRE_FLAG_TEMPLATE:
- raise error, "internal: unsupported template operator"
- emit(OPCODES[REPEAT])
- skip = len(code); emit(0)
- emit(av[0])
- emit(av[1])
- _compile(code, av[2], flags)
- emit(OPCODES[SUCCESS])
- code[skip] = len(code) - skip
- elif _simple(av) and op == MAX_REPEAT:
- emit(OPCODES[REPEAT_ONE])
- skip = len(code); emit(0)
- emit(av[0])
- emit(av[1])
- _compile(code, av[2], flags)
- emit(OPCODES[SUCCESS])
- code[skip] = len(code) - skip
- else:
- emit(OPCODES[REPEAT])
- skip = len(code); emit(0)
- emit(av[0])
- emit(av[1])
- _compile(code, av[2], flags)
- code[skip] = len(code) - skip
- if op == MAX_REPEAT:
- emit(OPCODES[MAX_UNTIL])
- else:
- emit(OPCODES[MIN_UNTIL])
- elif op is SUBPATTERN:
- if av[0]:
- emit(OPCODES[MARK])
- emit((av[0]-1)*2)
- # _compile_info(code, av[1], flags)
- _compile(code, av[1], flags)
- if av[0]:
- emit(OPCODES[MARK])
- emit((av[0]-1)*2+1)
- elif op in (SUCCESS, FAILURE):
- emit(OPCODES[op])
- elif op in (ASSERT, ASSERT_NOT):
- emit(OPCODES[op])
- skip = len(code); emit(0)
- if av[0] >= 0:
- emit(0) # look ahead
- else:
- lo, hi = av[1].getwidth()
- if lo != hi:
- raise error, "look-behind requires fixed-width pattern"
- emit(lo) # look behind
- _compile(code, av[1], flags)
- emit(OPCODES[SUCCESS])
- code[skip] = len(code) - skip
- elif op is CALL:
- emit(OPCODES[op])
- skip = len(code); emit(0)
- _compile(code, av, flags)
- emit(OPCODES[SUCCESS])
- code[skip] = len(code) - skip
- elif op is AT:
- emit(OPCODES[op])
- if flags & SRE_FLAG_MULTILINE:
- emit(ATCODES[AT_MULTILINE.get(av, av)])
- else:
- emit(ATCODES[av])
- elif op is BRANCH:
- emit(OPCODES[op])
- tail = []
- for av in av[1]:
- skip = len(code); emit(0)
- # _compile_info(code, av, flags)
- _compile(code, av, flags)
- emit(OPCODES[JUMP])
- tail.append(len(code)); emit(0)
- code[skip] = len(code) - skip
- emit(0) # end of branch
- for tail in tail:
- code[tail] = len(code) - tail
- elif op is CATEGORY:
- emit(OPCODES[op])
- if flags & SRE_FLAG_LOCALE:
- emit(CHCODES[CH_LOCALE[av]])
- elif flags & SRE_FLAG_UNICODE:
- emit(CHCODES[CH_UNICODE[av]])
- else:
- emit(CHCODES[av])
- elif op is GROUPREF:
- if flags & SRE_FLAG_IGNORECASE:
- emit(OPCODES[OP_IGNORE[op]])
- else:
- emit(OPCODES[op])
- emit(av-1)
- else:
- raise ValueError, ("unsupported operand type", op)
-
-def _compile_charset(charset, flags, code, fixup=None):
- # compile charset subprogram
- emit = code.append
- if not fixup:
- fixup = lambda x: x
- for op, av in _optimize_charset(charset, fixup):
- emit(OPCODES[op])
- if op is NEGATE:
- pass
- elif op is LITERAL:
- emit(fixup(av))
- elif op is RANGE:
- emit(fixup(av[0]))
- emit(fixup(av[1]))
- elif op is CHARSET:
- code.extend(av)
- elif op is CATEGORY:
- if flags & SRE_FLAG_LOCALE:
- emit(CHCODES[CH_LOCALE[av]])
- elif flags & SRE_FLAG_UNICODE:
- emit(CHCODES[CH_UNICODE[av]])
- else:
- emit(CHCODES[av])
- else:
- raise error, "internal: unsupported set operator"
- emit(OPCODES[FAILURE])
-
-def _optimize_charset(charset, fixup):
- # internal: optimize character set
- out = []
- charmap = [0]*256
- try:
- for op, av in charset:
- if op is NEGATE:
- out.append((op, av))
- elif op is LITERAL:
- charmap[fixup(av)] = 1
- elif op is RANGE:
- for i in range(fixup(av[0]), fixup(av[1])+1):
- charmap[i] = 1
- elif op is CATEGORY:
- # FIXME: could append to charmap tail
- return charset # cannot compress
- except IndexError:
- # character set contains unicode characters
- return charset
- # compress character map
- i = p = n = 0
- runs = []
- for c in charmap:
- if c:
- if n == 0:
- p = i
- n = n + 1
- elif n:
- runs.append((p, n))
- n = 0
- i = i + 1
- if n:
- runs.append((p, n))
- if len(runs) <= 2:
- # use literal/range
- for p, n in runs:
- if n == 1:
- out.append((LITERAL, p))
- else:
- out.append((RANGE, (p, p+n-1)))
- if len(out) < len(charset):
- return out
- else:
- # use bitmap
- data = []
- m = 1; v = 0
- for c in charmap:
- if c:
- v = v + m
- m = m << 1
- if m > MAXCODE:
- data.append(v)
- m = 1; v = 0
- out.append((CHARSET, data))
- return out
- return charset
-
-def _simple(av):
- # check if av is a "simple" operator
- lo, hi = av[2].getwidth()
- if lo == 0 and hi == MAXREPEAT:
- raise error, "nothing to repeat"
- return lo == hi == 1 and av[2][0][0] != SUBPATTERN
-
-def _compile_info(code, pattern, flags):
- # internal: compile an info block. in the current version,
- # this contains min/max pattern width, and an optional literal
- # prefix or a character map
- lo, hi = pattern.getwidth()
- if lo == 0:
- return # not worth it
- # look for a literal prefix
- prefix = []
- prefix_skip = 0
- charset = [] # not used
- if not (flags & SRE_FLAG_IGNORECASE):
- # look for literal prefix
- for op, av in pattern.data:
- if op is LITERAL:
- if len(prefix) == prefix_skip:
- prefix_skip = prefix_skip + 1
- prefix.append(av)
- elif op is SUBPATTERN and len(av[1]) == 1:
- op, av = av[1][0]
- if op is LITERAL:
- prefix.append(av)
- else:
- break
- else:
- break
- # if no prefix, look for charset prefix
- if not prefix and pattern.data:
- op, av = pattern.data[0]
- if op is SUBPATTERN and av[1]:
- op, av = av[1][0]
- if op is LITERAL:
- charset.append((op, av))
- elif op is BRANCH:
- c = []
- for p in av[1]:
- if not p:
- break
- op, av = p[0]
- if op is LITERAL:
- c.append((op, av))
- else:
- break
- else:
- charset = c
- elif op is BRANCH:
- c = []
- for p in av[1]:
- if not p:
- break
- op, av = p[0]
- if op is LITERAL:
- c.append((op, av))
- else:
- break
- else:
- charset = c
- elif op is IN:
- charset = av
-## if prefix:
-## print "*** PREFIX", prefix, prefix_skip
-## if charset:
-## print "*** CHARSET", charset
- # add an info block
- emit = code.append
- emit(OPCODES[INFO])
- skip = len(code); emit(0)
- # literal flag
- mask = 0
- if prefix:
- mask = SRE_INFO_PREFIX
- if len(prefix) == prefix_skip == len(pattern.data):
- mask = mask + SRE_INFO_LITERAL
- elif charset:
- mask = mask + SRE_INFO_CHARSET
- emit(mask)
- # pattern length
- if lo < MAXCODE:
- emit(lo)
- else:
- emit(MAXCODE)
- prefix = prefix[:MAXCODE]
- if hi < MAXCODE:
- emit(hi)
- else:
- emit(0)
- # add literal prefix
- if prefix:
- emit(len(prefix)) # length
- emit(prefix_skip) # skip
- code.extend(prefix)
- # generate overlap table
- table = [-1] + ([0]*len(prefix))
- for i in range(len(prefix)):
- table[i+1] = table[i]+1
- while table[i+1] > 0 and prefix[i] != prefix[table[i+1]-1]:
- table[i+1] = table[table[i+1]-1]+1
- code.extend(table[1:]) # don't store first entry
- elif charset:
- _compile_charset(charset, 0, code)
- code[skip] = len(code) - skip
-
-STRING_TYPES = [type("")]
-
-try:
- STRING_TYPES.append(type(unicode("")))
-except NameError:
- pass
-
-def _code(p, flags):
-
- flags = p.pattern.flags | flags
- code = []
-
- # compile info block
- _compile_info(code, p, flags)
-
- # compile the pattern
- _compile(code, p.data, flags)
-
- code.append(OPCODES[SUCCESS])
-
- return code
-
-def compile(p, flags=0):
- # internal: convert pattern list to internal format
-
- if type(p) in STRING_TYPES:
- import sre_parse
- pattern = p
- p = sre_parse.parse(p, flags)
- else:
- pattern = None
-
- code = _code(p, flags)
-
- # print code
-
- # FIXME: <fl> get rid of this limitation!
- assert p.pattern.groups <= 100,\
- "sorry, but this version only supports 100 named groups"
-
- # map in either direction
- groupindex = p.pattern.groupdict
- indexgroup = [None] * p.pattern.groups
- for k, i in groupindex.items():
- indexgroup[i] = k
-
- return _sre.compile(
- pattern, flags, code,
- p.pattern.groups-1,
- groupindex, indexgroup
- )
diff --git a/Lib/dos-8x3/sre_cons.py b/Lib/dos-8x3/sre_cons.py
deleted file mode 100644
index ea649c0..0000000
--- a/Lib/dos-8x3/sre_cons.py
+++ /dev/null
@@ -1,228 +0,0 @@
-#
-# Secret Labs' Regular Expression Engine
-#
-# various symbols used by the regular expression engine.
-# run this script to update the _sre include files!
-#
-# Copyright (c) 1998-2000 by Secret Labs AB. All rights reserved.
-#
-# See the sre.py file for information on usage and redistribution.
-#
-
-MAXREPEAT = 65535
-
-# should this really be here?
-
-class error(Exception):
- pass
-
-# operators
-
-FAILURE = "failure"
-SUCCESS = "success"
-
-ANY = "any"
-ANY_ALL = "any_all"
-ASSERT = "assert"
-ASSERT_NOT = "assert_not"
-AT = "at"
-BRANCH = "branch"
-CALL = "call"
-CATEGORY = "category"
-CHARSET = "charset"
-GROUPREF = "groupref"
-GROUPREF_IGNORE = "groupref_ignore"
-IN = "in"
-IN_IGNORE = "in_ignore"
-INFO = "info"
-JUMP = "jump"
-LITERAL = "literal"
-LITERAL_IGNORE = "literal_ignore"
-MARK = "mark"
-MAX_REPEAT = "max_repeat"
-MAX_UNTIL = "max_until"
-MIN_REPEAT = "min_repeat"
-MIN_UNTIL = "min_until"
-NEGATE = "negate"
-NOT_LITERAL = "not_literal"
-NOT_LITERAL_IGNORE = "not_literal_ignore"
-RANGE = "range"
-REPEAT = "repeat"
-REPEAT_ONE = "repeat_one"
-SUBPATTERN = "subpattern"
-
-# positions
-AT_BEGINNING = "at_beginning"
-AT_BEGINNING_LINE = "at_beginning_line"
-AT_BOUNDARY = "at_boundary"
-AT_NON_BOUNDARY = "at_non_boundary"
-AT_END = "at_end"
-AT_END_LINE = "at_end_line"
-
-# categories
-CATEGORY_DIGIT = "category_digit"
-CATEGORY_NOT_DIGIT = "category_not_digit"
-CATEGORY_SPACE = "category_space"
-CATEGORY_NOT_SPACE = "category_not_space"
-CATEGORY_WORD = "category_word"
-CATEGORY_NOT_WORD = "category_not_word"
-CATEGORY_LINEBREAK = "category_linebreak"
-CATEGORY_NOT_LINEBREAK = "category_not_linebreak"
-CATEGORY_LOC_WORD = "category_loc_word"
-CATEGORY_LOC_NOT_WORD = "category_loc_not_word"
-CATEGORY_UNI_DIGIT = "category_uni_digit"
-CATEGORY_UNI_NOT_DIGIT = "category_uni_not_digit"
-CATEGORY_UNI_SPACE = "category_uni_space"
-CATEGORY_UNI_NOT_SPACE = "category_uni_not_space"
-CATEGORY_UNI_WORD = "category_uni_word"
-CATEGORY_UNI_NOT_WORD = "category_uni_not_word"
-CATEGORY_UNI_LINEBREAK = "category_uni_linebreak"
-CATEGORY_UNI_NOT_LINEBREAK = "category_uni_not_linebreak"
-
-OPCODES = [
-
- # failure=0 success=1 (just because it looks better that way :-)
- FAILURE, SUCCESS,
-
- ANY, ANY_ALL,
- ASSERT, ASSERT_NOT,
- AT,
- BRANCH,
- CALL,
- CATEGORY,
- CHARSET,
- GROUPREF, GROUPREF_IGNORE,
- IN, IN_IGNORE,
- INFO,
- JUMP,
- LITERAL, LITERAL_IGNORE,
- MARK,
- MAX_UNTIL,
- MIN_UNTIL,
- NOT_LITERAL, NOT_LITERAL_IGNORE,
- NEGATE,
- RANGE,
- REPEAT,
- REPEAT_ONE,
- SUBPATTERN
-
-]
-
-ATCODES = [
- AT_BEGINNING, AT_BEGINNING_LINE, AT_BOUNDARY,
- AT_NON_BOUNDARY, AT_END, AT_END_LINE
-]
-
-CHCODES = [
- CATEGORY_DIGIT, CATEGORY_NOT_DIGIT, CATEGORY_SPACE,
- CATEGORY_NOT_SPACE, CATEGORY_WORD, CATEGORY_NOT_WORD,
- CATEGORY_LINEBREAK, CATEGORY_NOT_LINEBREAK, CATEGORY_LOC_WORD,
- CATEGORY_LOC_NOT_WORD, CATEGORY_UNI_DIGIT, CATEGORY_UNI_NOT_DIGIT,
- CATEGORY_UNI_SPACE, CATEGORY_UNI_NOT_SPACE, CATEGORY_UNI_WORD,
- CATEGORY_UNI_NOT_WORD, CATEGORY_UNI_LINEBREAK,
- CATEGORY_UNI_NOT_LINEBREAK
-]
-
-def makedict(list):
- d = {}
- i = 0
- for item in list:
- d[item] = i
- i = i + 1
- return d
-
-OPCODES = makedict(OPCODES)
-ATCODES = makedict(ATCODES)
-CHCODES = makedict(CHCODES)
-
-# replacement operations for "ignore case" mode
-OP_IGNORE = {
- GROUPREF: GROUPREF_IGNORE,
- IN: IN_IGNORE,
- LITERAL: LITERAL_IGNORE,
- NOT_LITERAL: NOT_LITERAL_IGNORE
-}
-
-AT_MULTILINE = {
- AT_BEGINNING: AT_BEGINNING_LINE,
- AT_END: AT_END_LINE
-}
-
-CH_LOCALE = {
- CATEGORY_DIGIT: CATEGORY_DIGIT,
- CATEGORY_NOT_DIGIT: CATEGORY_NOT_DIGIT,
- CATEGORY_SPACE: CATEGORY_SPACE,
- CATEGORY_NOT_SPACE: CATEGORY_NOT_SPACE,
- CATEGORY_WORD: CATEGORY_LOC_WORD,
- CATEGORY_NOT_WORD: CATEGORY_LOC_NOT_WORD,
- CATEGORY_LINEBREAK: CATEGORY_LINEBREAK,
- CATEGORY_NOT_LINEBREAK: CATEGORY_NOT_LINEBREAK
-}
-
-CH_UNICODE = {
- CATEGORY_DIGIT: CATEGORY_UNI_DIGIT,
- CATEGORY_NOT_DIGIT: CATEGORY_UNI_NOT_DIGIT,
- CATEGORY_SPACE: CATEGORY_UNI_SPACE,
- CATEGORY_NOT_SPACE: CATEGORY_UNI_NOT_SPACE,
- CATEGORY_WORD: CATEGORY_UNI_WORD,
- CATEGORY_NOT_WORD: CATEGORY_UNI_NOT_WORD,
- CATEGORY_LINEBREAK: CATEGORY_UNI_LINEBREAK,
- CATEGORY_NOT_LINEBREAK: CATEGORY_UNI_NOT_LINEBREAK
-}
-
-# flags
-SRE_FLAG_TEMPLATE = 1 # template mode (disable backtracking)
-SRE_FLAG_IGNORECASE = 2 # case insensitive
-SRE_FLAG_LOCALE = 4 # honour system locale
-SRE_FLAG_MULTILINE = 8 # treat target as multiline string
-SRE_FLAG_DOTALL = 16 # treat target as a single string
-SRE_FLAG_UNICODE = 32 # use unicode locale
-SRE_FLAG_VERBOSE = 64 # ignore whitespace and comments
-
-# flags for INFO primitive
-SRE_INFO_PREFIX = 1 # has prefix
-SRE_INFO_LITERAL = 2 # entire pattern is literal (given by prefix)
-SRE_INFO_CHARSET = 4 # pattern starts with character from given set
-
-if __name__ == "__main__":
- import string
- def dump(f, d, prefix):
- items = d.items()
- items.sort(lambda a, b: cmp(a[1], b[1]))
- for k, v in items:
- f.write("#define %s_%s %s\n" % (prefix, string.upper(k), v))
- f = open("sre_constants.h", "w")
- f.write("""\
-/*
- * Secret Labs' Regular Expression Engine
- *
- * regular expression matching engine
- *
- * NOTE: This file is generated by sre_constants.py. If you need
- * to change anything in here, edit sre_constants.py and run it.
- *
- * Copyright (c) 1997-2000 by Secret Labs AB. All rights reserved.
- *
- * See the _sre.c file for information on usage and redistribution.
- */
-
-""")
-
- dump(f, OPCODES, "SRE_OP")
- dump(f, ATCODES, "SRE")
- dump(f, CHCODES, "SRE")
-
- f.write("#define SRE_FLAG_TEMPLATE %d\n" % SRE_FLAG_TEMPLATE)
- f.write("#define SRE_FLAG_IGNORECASE %d\n" % SRE_FLAG_IGNORECASE)
- f.write("#define SRE_FLAG_LOCALE %d\n" % SRE_FLAG_LOCALE)
- f.write("#define SRE_FLAG_MULTILINE %d\n" % SRE_FLAG_MULTILINE)
- f.write("#define SRE_FLAG_DOTALL %d\n" % SRE_FLAG_DOTALL)
- f.write("#define SRE_FLAG_UNICODE %d\n" % SRE_FLAG_UNICODE)
- f.write("#define SRE_FLAG_VERBOSE %d\n" % SRE_FLAG_VERBOSE)
-
- f.write("#define SRE_INFO_PREFIX %d\n" % SRE_INFO_PREFIX)
- f.write("#define SRE_INFO_LITERAL %d\n" % SRE_INFO_LITERAL)
- f.write("#define SRE_INFO_CHARSET %d\n" % SRE_INFO_CHARSET)
-
- f.close()
- print "done"
diff --git a/Lib/dos-8x3/sre_pars.py b/Lib/dos-8x3/sre_pars.py
deleted file mode 100644
index 7c36d4f..0000000
--- a/Lib/dos-8x3/sre_pars.py
+++ /dev/null
@@ -1,682 +0,0 @@
-#
-# Secret Labs' Regular Expression Engine
-#
-# convert re-style regular expression to sre pattern
-#
-# Copyright (c) 1998-2000 by Secret Labs AB. All rights reserved.
-#
-# See the sre.py file for information on usage and redistribution.
-#
-
-import string, sys
-
-from sre_constants import *
-
-SPECIAL_CHARS = ".\\[{()*+?^$|"
-REPEAT_CHARS = "*+?{"
-
-DIGITS = tuple("0123456789")
-
-OCTDIGITS = tuple("01234567")
-HEXDIGITS = tuple("0123456789abcdefABCDEF")
-
-WHITESPACE = tuple(" \t\n\r\v\f")
-
-ESCAPES = {
- r"\a": (LITERAL, 7),
- r"\b": (LITERAL, 8),
- r"\f": (LITERAL, 12),
- r"\n": (LITERAL, 10),
- r"\r": (LITERAL, 13),
- r"\t": (LITERAL, 9),
- r"\v": (LITERAL, 11),
- r"\\": (LITERAL, ord("\\"))
-}
-
-CATEGORIES = {
- r"\A": (AT, AT_BEGINNING), # start of string
- r"\b": (AT, AT_BOUNDARY),
- r"\B": (AT, AT_NON_BOUNDARY),
- r"\d": (IN, [(CATEGORY, CATEGORY_DIGIT)]),
- r"\D": (IN, [(CATEGORY, CATEGORY_NOT_DIGIT)]),
- r"\s": (IN, [(CATEGORY, CATEGORY_SPACE)]),
- r"\S": (IN, [(CATEGORY, CATEGORY_NOT_SPACE)]),
- r"\w": (IN, [(CATEGORY, CATEGORY_WORD)]),
- r"\W": (IN, [(CATEGORY, CATEGORY_NOT_WORD)]),
- r"\Z": (AT, AT_END), # end of string
-}
-
-FLAGS = {
- # standard flags
- "i": SRE_FLAG_IGNORECASE,
- "L": SRE_FLAG_LOCALE,
- "m": SRE_FLAG_MULTILINE,
- "s": SRE_FLAG_DOTALL,
- "x": SRE_FLAG_VERBOSE,
- # extensions
- "t": SRE_FLAG_TEMPLATE,
- "u": SRE_FLAG_UNICODE,
-}
-
-class Pattern:
- # master pattern object. keeps track of global attributes
- def __init__(self):
- self.flags = 0
- self.groups = 1
- self.groupdict = {}
- def getgroup(self, name=None):
- gid = self.groups
- self.groups = gid + 1
- if name:
- self.groupdict[name] = gid
- return gid
-
-class SubPattern:
- # a subpattern, in intermediate form
- def __init__(self, pattern, data=None):
- self.pattern = pattern
- if not data:
- data = []
- self.data = data
- self.width = None
- def dump(self, level=0):
- nl = 1
- for op, av in self.data:
- print level*" " + op,; nl = 0
- if op == "in":
- # member sublanguage
- print; nl = 1
- for op, a in av:
- print (level+1)*" " + op, a
- elif op == "branch":
- print; nl = 1
- i = 0
- for a in av[1]:
- if i > 0:
- print level*" " + "or"
- a.dump(level+1); nl = 1
- i = i + 1
- elif type(av) in (type(()), type([])):
- for a in av:
- if isinstance(a, SubPattern):
- if not nl: print
- a.dump(level+1); nl = 1
- else:
- print a, ; nl = 0
- else:
- print av, ; nl = 0
- if not nl: print
- def __repr__(self):
- return repr(self.data)
- def __len__(self):
- return len(self.data)
- def __delitem__(self, index):
- del self.data[index]
- def __getitem__(self, index):
- return self.data[index]
- def __setitem__(self, index, code):
- self.data[index] = code
- def __getslice__(self, start, stop):
- return SubPattern(self.pattern, self.data[start:stop])
- def insert(self, index, code):
- self.data.insert(index, code)
- def append(self, code):
- self.data.append(code)
- def getwidth(self):
- # determine the width (min, max) for this subpattern
- if self.width:
- return self.width
- lo = hi = 0L
- for op, av in self.data:
- if op is BRANCH:
- i = sys.maxint
- j = 0
- for av in av[1]:
- l, h = av.getwidth()
- i = min(i, l)
- j = max(j, h)
- lo = lo + i
- hi = hi + j
- elif op is CALL:
- i, j = av.getwidth()
- lo = lo + i
- hi = hi + j
- elif op is SUBPATTERN:
- i, j = av[1].getwidth()
- lo = lo + i
- hi = hi + j
- elif op in (MIN_REPEAT, MAX_REPEAT):
- i, j = av[2].getwidth()
- lo = lo + long(i) * av[0]
- hi = hi + long(j) * av[1]
- elif op in (ANY, RANGE, IN, LITERAL, NOT_LITERAL, CATEGORY):
- lo = lo + 1
- hi = hi + 1
- elif op == SUCCESS:
- break
- self.width = int(min(lo, sys.maxint)), int(min(hi, sys.maxint))
- return self.width
-
-class Tokenizer:
- def __init__(self, string):
- self.string = string
- self.index = 0
- self.__next()
- def __next(self):
- if self.index >= len(self.string):
- self.next = None
- return
- char = self.string[self.index]
- if char[0] == "\\":
- try:
- c = self.string[self.index + 1]
- except IndexError:
- raise error, "bogus escape"
- char = char + c
- self.index = self.index + len(char)
- self.next = char
- def match(self, char, skip=1):
- if char == self.next:
- if skip:
- self.__next()
- return 1
- return 0
- def get(self):
- this = self.next
- self.__next()
- return this
- def tell(self):
- return self.index, self.next
- def seek(self, index):
- self.index, self.next = index
-
-def isident(char):
- return "a" <= char <= "z" or "A" <= char <= "Z" or char == "_"
-
-def isdigit(char):
- return "0" <= char <= "9"
-
-def isname(name):
- # check that group name is a valid string
- if not isident(name[0]):
- return 0
- for char in name:
- if not isident(char) and not isdigit(char):
- return 0
- return 1
-
-def _group(escape, groups):
- # check if the escape string represents a valid group
- try:
- gid = int(escape[1:])
- if gid and gid < groups:
- return gid
- except ValueError:
- pass
- return None # not a valid group
-
-def _class_escape(source, escape):
- # handle escape code inside character class
- code = ESCAPES.get(escape)
- if code:
- return code
- code = CATEGORIES.get(escape)
- if code:
- return code
- try:
- if escape[1:2] == "x":
- # hexadecimal escape (exactly two digits)
- while source.next in HEXDIGITS and len(escape) < 4:
- escape = escape + source.get()
- escape = escape[2:]
- if len(escape) != 2:
- raise error, "bogus escape: %s" % repr("\\" + escape)
- return LITERAL, int(escape, 16) & 0xff
- elif str(escape[1:2]) in OCTDIGITS:
- # octal escape (up to three digits)
- while source.next in OCTDIGITS and len(escape) < 5:
- escape = escape + source.get()
- escape = escape[1:]
- return LITERAL, int(escape, 8) & 0xff
- if len(escape) == 2:
- return LITERAL, ord(escape[1])
- except ValueError:
- pass
- raise error, "bogus escape: %s" % repr(escape)
-
-def _escape(source, escape, state):
- # handle escape code in expression
- code = CATEGORIES.get(escape)
- if code:
- return code
- code = ESCAPES.get(escape)
- if code:
- return code
- try:
- if escape[1:2] == "x":
- # hexadecimal escape
- while source.next in HEXDIGITS and len(escape) < 4:
- escape = escape + source.get()
- if len(escape) != 4:
- raise ValueError
- return LITERAL, int(escape[2:], 16) & 0xff
- elif escape[1:2] == "0":
- # octal escape
- while source.next in OCTDIGITS and len(escape) < 4:
- escape = escape + source.get()
- return LITERAL, int(escape[1:], 8) & 0xff
- elif escape[1:2] in DIGITS:
- # octal escape *or* decimal group reference (sigh)
- here = source.tell()
- if source.next in DIGITS:
- escape = escape + source.get()
- if (escape[1] in OCTDIGITS and escape[2] in OCTDIGITS and
- source.next in OCTDIGITS):
- # got three octal digits; this is an octal escape
- escape = escape + source.get()
- return LITERAL, int(escape[1:], 8) & 0xff
- # got at least one decimal digit; this is a group reference
- group = _group(escape, state.groups)
- if group:
- return GROUPREF, group
- raise ValueError
- if len(escape) == 2:
- return LITERAL, ord(escape[1])
- except ValueError:
- pass
- raise error, "bogus escape: %s" % repr(escape)
-
-def _parse_sub(source, state, nested=1):
- # parse an alternation: a|b|c
-
- items = []
- while 1:
- items.append(_parse(source, state))
- if source.match("|"):
- continue
- if not nested:
- break
- if not source.next or source.match(")", 0):
- break
- else:
- raise error, "pattern not properly closed"
-
- if len(items) == 1:
- return items[0]
-
- subpattern = SubPattern(state)
-
- # check if all items share a common prefix
- while 1:
- prefix = None
- for item in items:
- if not item:
- break
- if prefix is None:
- prefix = item[0]
- elif item[0] != prefix:
- break
- else:
- # all subitems start with a common "prefix".
- # move it out of the branch
- for item in items:
- del item[0]
- subpattern.append(prefix)
- continue # check next one
- break
-
- # check if the branch can be replaced by a character set
- for item in items:
- if len(item) != 1 or item[0][0] != LITERAL:
- break
- else:
- # we can store this as a character set instead of a
- # branch (the compiler may optimize this even more)
- set = []
- for item in items:
- set.append(item[0])
- subpattern.append((IN, set))
- return subpattern
-
- subpattern.append((BRANCH, (None, items)))
- return subpattern
-
-def _parse(source, state):
- # parse a simple pattern
-
- subpattern = SubPattern(state)
-
- while 1:
-
- if source.next in ("|", ")"):
- break # end of subpattern
- this = source.get()
- if this is None:
- break # end of pattern
-
- if state.flags & SRE_FLAG_VERBOSE:
- # skip whitespace and comments
- if this in WHITESPACE:
- continue
- if this == "#":
- while 1:
- this = source.get()
- if this in (None, "\n"):
- break
- continue
-
- if this and this[0] not in SPECIAL_CHARS:
- subpattern.append((LITERAL, ord(this)))
-
- elif this == "[":
- # character set
- set = []
-## if source.match(":"):
-## pass # handle character classes
- if source.match("^"):
- set.append((NEGATE, None))
- # check remaining characters
- start = set[:]
- while 1:
- this = source.get()
- if this == "]" and set != start:
- break
- elif this and this[0] == "\\":
- code1 = _class_escape(source, this)
- elif this:
- code1 = LITERAL, ord(this)
- else:
- raise error, "unexpected end of regular expression"
- if source.match("-"):
- # potential range
- this = source.get()
- if this == "]":
- if code1[0] is IN:
- code1 = code1[1][0]
- set.append(code1)
- set.append((LITERAL, ord("-")))
- break
- else:
- if this[0] == "\\":
- code2 = _class_escape(source, this)
- else:
- code2 = LITERAL, ord(this)
- if code1[0] != LITERAL or code2[0] != LITERAL:
- raise error, "illegal range"
- lo = code1[1]
- hi = code2[1]
- if hi < lo:
- raise error, "illegal range"
- set.append((RANGE, (lo, hi)))
- else:
- if code1[0] is IN:
- code1 = code1[1][0]
- set.append(code1)
-
- # FIXME: <fl> move set optimization to compiler!
- if len(set)==1 and set[0][0] is LITERAL:
- subpattern.append(set[0]) # optimization
- elif len(set)==2 and set[0][0] is NEGATE and set[1][0] is LITERAL:
- subpattern.append((NOT_LITERAL, set[1][1])) # optimization
- else:
- # FIXME: <fl> add charmap optimization
- subpattern.append((IN, set))
-
- elif this and this[0] in REPEAT_CHARS:
- # repeat previous item
- if this == "?":
- min, max = 0, 1
- elif this == "*":
- min, max = 0, MAXREPEAT
- elif this == "+":
- min, max = 1, MAXREPEAT
- elif this == "{":
- here = source.tell()
- min, max = 0, MAXREPEAT
- lo = hi = ""
- while source.next in DIGITS:
- lo = lo + source.get()
- if source.match(","):
- while source.next in DIGITS:
- hi = hi + source.get()
- else:
- hi = lo
- if not source.match("}"):
- subpattern.append((LITERAL, ord(this)))
- source.seek(here)
- continue
- if lo:
- min = int(lo)
- if hi:
- max = int(hi)
- # FIXME: <fl> check that hi >= lo!
- else:
- raise error, "not supported"
- # figure out which item to repeat
- if subpattern:
- item = subpattern[-1:]
- else:
- raise error, "nothing to repeat"
- if source.match("?"):
- subpattern[-1] = (MIN_REPEAT, (min, max, item))
- else:
- subpattern[-1] = (MAX_REPEAT, (min, max, item))
-
- elif this == ".":
- subpattern.append((ANY, None))
-
- elif this == "(":
- group = 1
- name = None
- if source.match("?"):
- group = 0
- # options
- if source.match("P"):
- # python extensions
- if source.match("<"):
- # named group: skip forward to end of name
- name = ""
- while 1:
- char = source.get()
- if char is None:
- raise error, "unterminated name"
- if char == ">":
- break
- name = name + char
- group = 1
- if not isname(name):
- raise error, "illegal character in group name"
- elif source.match("="):
- # named backreference
- name = ""
- while 1:
- char = source.get()
- if char is None:
- raise error, "unterminated name"
- if char == ")":
- break
- name = name + char
- if not isname(name):
- raise error, "illegal character in group name"
- gid = state.groupdict.get(name)
- if gid is None:
- raise error, "unknown group name"
- subpattern.append((GROUPREF, gid))
- continue
- else:
- char = source.get()
- if char is None:
- raise error, "unexpected end of pattern"
- raise error, "unknown specifier: ?P%s" % char
- elif source.match(":"):
- # non-capturing group
- group = 2
- elif source.match("#"):
- # comment
- while 1:
- if source.next is None or source.next == ")":
- break
- source.get()
- if not source.match(")"):
- raise error, "unbalanced parenthesis"
- continue
- elif source.next in ("=", "!", "<"):
- # lookahead assertions
- char = source.get()
- dir = 1
- if char == "<":
- if source.next not in ("=", "!"):
- raise error, "syntax error"
- dir = -1 # lookbehind
- char = source.get()
- p = _parse_sub(source, state)
- if not source.match(")"):
- raise error, "unbalanced parenthesis"
- if char == "=":
- subpattern.append((ASSERT, (dir, p)))
- else:
- subpattern.append((ASSERT_NOT, (dir, p)))
- continue
- else:
- # flags
- while FLAGS.has_key(source.next):
- state.flags = state.flags | FLAGS[source.get()]
- if group:
- # parse group contents
- if group == 2:
- # anonymous group
- group = None
- else:
- group = state.getgroup(name)
- p = _parse_sub(source, state)
- if not source.match(")"):
- raise error, "unbalanced parenthesis"
- subpattern.append((SUBPATTERN, (group, p)))
- else:
- while 1:
- char = source.get()
- if char is None or char == ")":
- break
- raise error, "unknown extension"
-
- elif this == "^":
- subpattern.append((AT, AT_BEGINNING))
-
- elif this == "$":
- subpattern.append((AT, AT_END))
-
- elif this and this[0] == "\\":
- code = _escape(source, this, state)
- subpattern.append(code)
-
- else:
- raise error, "parser error"
-
- return subpattern
-
-def parse(str, flags=0, pattern=None):
- # parse 're' pattern into list of (opcode, argument) tuples
-
- source = Tokenizer(str)
-
- if pattern is None:
- pattern = Pattern()
- pattern.flags = flags
-
- p = _parse_sub(source, pattern, 0)
-
- tail = source.get()
- if tail == ")":
- raise error, "unbalanced parenthesis"
- elif tail:
- raise error, "bogus characters at end of regular expression"
-
- # p.dump()
-
- if not (flags & SRE_FLAG_VERBOSE) and p.pattern.flags & SRE_FLAG_VERBOSE:
- # the VERBOSE flag was switched on inside the pattern. to be
- # on the safe side, we'll parse the whole thing again...
- return parse(str, p.pattern.flags)
-
- return p
-
-def parse_template(source, pattern):
- # parse 're' replacement string into list of literals and
- # group references
- s = Tokenizer(source)
- p = []
- a = p.append
- while 1:
- this = s.get()
- if this is None:
- break # end of replacement string
- if this and this[0] == "\\":
- # group
- if this == "\\g":
- name = ""
- if s.match("<"):
- while 1:
- char = s.get()
- if char is None:
- raise error, "unterminated group name"
- if char == ">":
- break
- name = name + char
- if not name:
- raise error, "bad group name"
- try:
- index = int(name)
- except ValueError:
- if not isname(name):
- raise error, "illegal character in group name"
- try:
- index = pattern.groupindex[name]
- except KeyError:
- raise IndexError, "unknown group name"
- a((MARK, index))
- elif len(this) > 1 and this[1] in DIGITS:
- code = None
- while 1:
- group = _group(this, pattern.groups+1)
- if group:
- if (s.next not in DIGITS or
- not _group(this + s.next, pattern.groups+1)):
- code = MARK, int(group)
- break
- elif s.next in OCTDIGITS:
- this = this + s.get()
- else:
- break
- if not code:
- this = this[1:]
- code = LITERAL, int(this[-6:], 8) & 0xff
- a(code)
- else:
- try:
- a(ESCAPES[this])
- except KeyError:
- for c in this:
- a((LITERAL, ord(c)))
- else:
- a((LITERAL, ord(this)))
- return p
-
-def expand_template(template, match):
- # FIXME: <fl> this is sooooo slow. drop in the slicelist
- # code instead
- p = []
- a = p.append
- sep = match.string[:0]
- if type(sep) is type(""):
- char = chr
- else:
- char = unichr
- for c, s in template:
- if c is LITERAL:
- a(char(s))
- elif c is MARK:
- s = match.group(s)
- if s is None:
- raise error, "empty group"
- a(s)
- return string.join(p, sep)
diff --git a/Lib/dos-8x3/statcach.py b/Lib/dos-8x3/statcach.py
deleted file mode 100755
index b5147c2..0000000
--- a/Lib/dos-8x3/statcach.py
+++ /dev/null
@@ -1,75 +0,0 @@
-"""Maintain a cache of stat() information on files.
-
-There are functions to reset the cache or to selectively remove items.
-"""
-
-import os
-from stat import *
-
-# The cache.
-# Keys are pathnames, values are `os.stat' outcomes.
-#
-cache = {}
-
-
-def stat(path):
- """Stat a file, possibly out of the cache."""
- if cache.has_key(path):
- return cache[path]
- cache[path] = ret = os.stat(path)
- return ret
-
-
-def reset():
- """Reset the cache completely."""
- global cache
- cache = {}
-
-
-def forget(path):
- """Remove a given item from the cache, if it exists."""
- if cache.has_key(path):
- del cache[path]
-
-
-def forget_prefix(prefix):
- """Remove all pathnames with a given prefix."""
- n = len(prefix)
- for path in cache.keys():
- if path[:n] == prefix:
- del cache[path]
-
-
-def forget_dir(prefix):
- """Forget about a directory and all entries in it, but not about
- entries in subdirectories."""
- if prefix[-1:] == '/' and prefix <> '/':
- prefix = prefix[:-1]
- forget(prefix)
- if prefix[-1:] <> '/':
- prefix = prefix + '/'
- n = len(prefix)
- for path in cache.keys():
- if path[:n] == prefix:
- rest = path[n:]
- if rest[-1:] == '/': rest = rest[:-1]
- if '/' not in rest:
- del cache[path]
-
-
-def forget_except_prefix(prefix):
- """Remove all pathnames except with a given prefix.
- Normally used with prefix = '/' after a chdir()."""
- n = len(prefix)
- for path in cache.keys():
- if path[:n] <> prefix:
- del cache[path]
-
-
-def isdir(path):
- """Check for directory."""
- try:
- st = stat(path)
- except os.error:
- return 0
- return S_ISDIR(st[ST_MODE])
diff --git a/Lib/dos-8x3/string_t.py b/Lib/dos-8x3/string_t.py
deleted file mode 100644
index d4041be..0000000
--- a/Lib/dos-8x3/string_t.py
+++ /dev/null
@@ -1,202 +0,0 @@
-"""Common tests shared by test_string and test_userstring"""
-
-import string
-
-transtable = '\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037 !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`xyzdefghijklmnopqrstuvwxyz{|}~\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377'
-
-from UserList import UserList
-
-class Sequence:
- def __init__(self): self.seq = 'wxyz'
- def __len__(self): return len(self.seq)
- def __getitem__(self, i): return self.seq[i]
-
-class BadSeq1(Sequence):
- def __init__(self): self.seq = [7, 'hello', 123L]
-
-class BadSeq2(Sequence):
- def __init__(self): self.seq = ['a', 'b', 'c']
- def __len__(self): return 8
-
-def run_module_tests(test):
- """Run all tests that exercise a function in the string module"""
-
- test('atoi', " 1 ", 1)
- test('atoi', " 1x", ValueError)
- test('atoi', " x1 ", ValueError)
- test('atol', " 1 ", 1L)
- test('atol', " 1x ", ValueError)
- test('atol', " x1 ", ValueError)
- test('atof', " 1 ", 1.0)
- test('atof', " 1x ", ValueError)
- test('atof', " x1 ", ValueError)
-
- test('maketrans', 'abc', transtable, 'xyz')
- test('maketrans', 'abc', ValueError, 'xyzq')
-
- # join now works with any sequence type
- test('join', ['a', 'b', 'c', 'd'], 'a b c d')
- test('join', ('a', 'b', 'c', 'd'), 'abcd', '')
- test('join', Sequence(), 'w x y z')
- test('join', 7, TypeError)
-
- test('join', BadSeq1(), TypeError)
- test('join', BadSeq2(), 'a b c')
-
- # try a few long ones
- print string.join(['x' * 100] * 100, ':')
- print string.join(('x' * 100,) * 100, ':')
-
-
-def run_method_tests(test):
- """Run all tests that exercise a method of a string object"""
-
- test('capitalize', ' hello ', ' hello ')
- test('capitalize', 'hello ', 'Hello ')
- test('find', 'abcdefghiabc', 0, 'abc')
- test('find', 'abcdefghiabc', 9, 'abc', 1)
- test('find', 'abcdefghiabc', -1, 'def', 4)
- test('rfind', 'abcdefghiabc', 9, 'abc')
- test('lower', 'HeLLo', 'hello')
- test('lower', 'hello', 'hello')
- test('upper', 'HeLLo', 'HELLO')
- test('upper', 'HELLO', 'HELLO')
-
- test('title', ' hello ', ' Hello ')
- test('title', 'hello ', 'Hello ')
- test('title', "fOrMaT thIs aS titLe String", 'Format This As Title String')
- test('title', "fOrMaT,thIs-aS*titLe;String", 'Format,This-As*Title;String')
- test('title', "getInt", 'Getint')
-
- test('expandtabs', 'abc\rab\tdef\ng\thi', 'abc\rab def\ng hi')
- test('expandtabs', 'abc\rab\tdef\ng\thi', 'abc\rab def\ng hi', 8)
- test('expandtabs', 'abc\rab\tdef\ng\thi', 'abc\rab def\ng hi', 4)
- test('expandtabs', 'abc\r\nab\tdef\ng\thi', 'abc\r\nab def\ng hi', 4)
-
- test('islower', 'a', 1)
- test('islower', 'A', 0)
- test('islower', '\n', 0)
- test('islower', 'abc', 1)
- test('islower', 'aBc', 0)
- test('islower', 'abc\n', 1)
-
- test('isupper', 'a', 0)
- test('isupper', 'A', 1)
- test('isupper', '\n', 0)
- test('isupper', 'ABC', 1)
- test('isupper', 'AbC', 0)
- test('isupper', 'ABC\n', 1)
-
- test('istitle', 'a', 0)
- test('istitle', 'A', 1)
- test('istitle', '\n', 0)
- test('istitle', 'A Titlecased Line', 1)
- test('istitle', 'A\nTitlecased Line', 1)
- test('istitle', 'A Titlecased, Line', 1)
- test('istitle', 'Not a capitalized String', 0)
- test('istitle', 'Not\ta Titlecase String', 0)
- test('istitle', 'Not--a Titlecase String', 0)
-
- test('isalpha', 'a', 1)
- test('isalpha', 'A', 1)
- test('isalpha', '\n', 0)
- test('isalpha', 'abc', 1)
- test('isalpha', 'aBc123', 0)
- test('isalpha', 'abc\n', 0)
-
- test('isalnum', 'a', 1)
- test('isalnum', 'A', 1)
- test('isalnum', '\n', 0)
- test('isalnum', '123abc456', 1)
- test('isalnum', 'a1b3c', 1)
- test('isalnum', 'aBc000 ', 0)
- test('isalnum', 'abc\n', 0)
-
- # join now works with any sequence type
- test('join', ' ', 'a b c d', ['a', 'b', 'c', 'd'])
- test('join', '', 'abcd', ('a', 'b', 'c', 'd'))
- test('join', ' ', 'w x y z', Sequence())
- test('join', 'a', 'abc', ('abc',))
- test('join', 'a', 'z', UserList(['z']))
- test('join', u'.', u'a.b.c', ['a', 'b', 'c'])
- test('join', '.', u'a.b.c', [u'a', 'b', 'c'])
- test('join', '.', u'a.b.c', ['a', u'b', 'c'])
- test('join', '.', u'a.b.c', ['a', 'b', u'c'])
- test('join', '.', TypeError, ['a', u'b', 3])
- for i in [5, 25, 125]:
- test('join', '-', ((('a' * i) + '-') * i)[:-1],
- ['a' * i] * i)
-
- test('join', ' ', TypeError, BadSeq1())
- test('join', ' ', 'a b c', BadSeq2())
-
- test('splitlines', "abc\ndef\n\rghi", ['abc', 'def', '', 'ghi'])
- test('splitlines', "abc\ndef\n\r\nghi", ['abc', 'def', '', 'ghi'])
- test('splitlines', "abc\ndef\r\nghi", ['abc', 'def', 'ghi'])
- test('splitlines', "abc\ndef\r\nghi\n", ['abc', 'def', 'ghi'])
- test('splitlines', "abc\ndef\r\nghi\n\r", ['abc', 'def', 'ghi', ''])
- test('splitlines', "\nabc\ndef\r\nghi\n\r", ['', 'abc', 'def', 'ghi', ''])
- test('splitlines', "\nabc\ndef\r\nghi\n\r", ['\n', 'abc\n', 'def\r\n', 'ghi\n', '\r'], 1)
-
- test('split', 'this is the split function',
- ['this', 'is', 'the', 'split', 'function'])
- test('split', 'a|b|c|d', ['a', 'b', 'c', 'd'], '|')
- test('split', 'a|b|c|d', ['a', 'b', 'c|d'], '|', 2)
- test('split', 'a b c d', ['a', 'b c d'], None, 1)
- test('split', 'a b c d', ['a', 'b', 'c d'], None, 2)
- test('split', 'a b c d', ['a', 'b', 'c', 'd'], None, 3)
- test('split', 'a b c d', ['a', 'b', 'c', 'd'], None, 4)
- test('split', 'a b c d', ['a b c d'], None, 0)
- test('split', 'a b c d', ['a', 'b', 'c d'], None, 2)
- test('split', 'a b c d ', ['a', 'b', 'c', 'd'])
-
- test('strip', ' hello ', 'hello')
- test('lstrip', ' hello ', 'hello ')
- test('rstrip', ' hello ', ' hello')
- test('strip', 'hello', 'hello')
-
- test('swapcase', 'HeLLo cOmpUteRs', 'hEllO CoMPuTErS')
- test('translate', 'xyzabcdef', 'xyzxyz', transtable, 'def')
-
- table = string.maketrans('a', 'A')
- test('translate', 'abc', 'Abc', table)
- test('translate', 'xyz', 'xyz', table)
-
- test('replace', 'one!two!three!', 'one@two!three!', '!', '@', 1)
- test('replace', 'one!two!three!', 'onetwothree', '!', '')
- test('replace', 'one!two!three!', 'one@two@three!', '!', '@', 2)
- test('replace', 'one!two!three!', 'one@two@three@', '!', '@', 3)
- test('replace', 'one!two!three!', 'one@two@three@', '!', '@', 4)
- test('replace', 'one!two!three!', 'one!two!three!', '!', '@', 0)
- test('replace', 'one!two!three!', 'one@two@three@', '!', '@')
- test('replace', 'one!two!three!', 'one!two!three!', 'x', '@')
- test('replace', 'one!two!three!', 'one!two!three!', 'x', '@', 2)
-
- test('startswith', 'hello', 1, 'he')
- test('startswith', 'hello', 1, 'hello')
- test('startswith', 'hello', 0, 'hello world')
- test('startswith', 'hello', 1, '')
- test('startswith', 'hello', 0, 'ello')
- test('startswith', 'hello', 1, 'ello', 1)
- test('startswith', 'hello', 1, 'o', 4)
- test('startswith', 'hello', 0, 'o', 5)
- test('startswith', 'hello', 1, '', 5)
- test('startswith', 'hello', 0, 'lo', 6)
- test('startswith', 'helloworld', 1, 'lowo', 3)
- test('startswith', 'helloworld', 1, 'lowo', 3, 7)
- test('startswith', 'helloworld', 0, 'lowo', 3, 6)
-
- test('endswith', 'hello', 1, 'lo')
- test('endswith', 'hello', 0, 'he')
- test('endswith', 'hello', 1, '')
- test('endswith', 'hello', 0, 'hello world')
- test('endswith', 'helloworld', 0, 'worl')
- test('endswith', 'helloworld', 1, 'worl', 3, 9)
- test('endswith', 'helloworld', 1, 'world', 3, 12)
- test('endswith', 'helloworld', 1, 'lowo', 1, 7)
- test('endswith', 'helloworld', 1, 'lowo', 2, 7)
- test('endswith', 'helloworld', 1, 'lowo', 3, 7)
- test('endswith', 'helloworld', 0, 'lowo', 4, 7)
- test('endswith', 'helloworld', 0, 'lowo', 3, 8)
- test('endswith', 'ab', 0, 'ab', 0, 1)
- test('endswith', 'ab', 0, 'ab', 0, 0)
diff --git a/Lib/dos-8x3/stringio.py b/Lib/dos-8x3/stringio.py
deleted file mode 100755
index 6952b1a..0000000
--- a/Lib/dos-8x3/stringio.py
+++ /dev/null
@@ -1,193 +0,0 @@
-"""File-like objects that read from or write to a string buffer.
-
-This implements (nearly) all stdio methods.
-
-f = StringIO() # ready for writing
-f = StringIO(buf) # ready for reading
-f.close() # explicitly release resources held
-flag = f.isatty() # always false
-pos = f.tell() # get current position
-f.seek(pos) # set current position
-f.seek(pos, mode) # mode 0: absolute; 1: relative; 2: relative to EOF
-buf = f.read() # read until EOF
-buf = f.read(n) # read up to n bytes
-buf = f.readline() # read until end of line ('\n') or EOF
-list = f.readlines()# list of f.readline() results until EOF
-f.truncate([size]) # truncate file at to at most size (default: current pos)
-f.write(buf) # write at current position
-f.writelines(list) # for line in list: f.write(line)
-f.getvalue() # return whole file's contents as a string
-
-Notes:
-- Using a real file is often faster (but less convenient).
-- There's also a much faster implementation in C, called cStringIO, but
- it's not subclassable.
-- fileno() is left unimplemented so that code which uses it triggers
- an exception early.
-- Seeking far beyond EOF and then writing will insert real null
- bytes that occupy space in the buffer.
-- There's a simple test set (see end of this file).
-"""
-
-import errno
-import string
-
-class StringIO:
- def __init__(self, buf = ''):
- self.buf = buf
- self.len = len(buf)
- self.buflist = []
- self.pos = 0
- self.closed = 0
- self.softspace = 0
- def close(self):
- if not self.closed:
- self.closed = 1
- del self.buf, self.pos
- def isatty(self):
- if self.closed:
- raise ValueError, "I/O operation on closed file"
- return 0
- def seek(self, pos, mode = 0):
- if self.closed:
- raise ValueError, "I/O operation on closed file"
- if self.buflist:
- self.buf = self.buf + string.joinfields(self.buflist, '')
- self.buflist = []
- if mode == 1:
- pos = pos + self.pos
- elif mode == 2:
- pos = pos + self.len
- self.pos = max(0, pos)
- def tell(self):
- if self.closed:
- raise ValueError, "I/O operation on closed file"
- return self.pos
- def read(self, n = -1):
- if self.closed:
- raise ValueError, "I/O operation on closed file"
- if self.buflist:
- self.buf = self.buf + string.joinfields(self.buflist, '')
- self.buflist = []
- if n < 0:
- newpos = self.len
- else:
- newpos = min(self.pos+n, self.len)
- r = self.buf[self.pos:newpos]
- self.pos = newpos
- return r
- def readline(self, length=None):
- if self.closed:
- raise ValueError, "I/O operation on closed file"
- if self.buflist:
- self.buf = self.buf + string.joinfields(self.buflist, '')
- self.buflist = []
- i = string.find(self.buf, '\n', self.pos)
- if i < 0:
- newpos = self.len
- else:
- newpos = i+1
- if length is not None:
- if self.pos + length < newpos:
- newpos = self.pos + length
- r = self.buf[self.pos:newpos]
- self.pos = newpos
- return r
- def readlines(self, sizehint = 0):
- total = 0
- lines = []
- line = self.readline()
- while line:
- lines.append(line)
- total += len(line)
- if 0 < sizehint <= total:
- break
- line = self.readline()
- return lines
- def truncate(self, size=None):
- if self.closed:
- raise ValueError, "I/O operation on closed file"
- if size is None:
- size = self.pos
- elif size < 0:
- raise IOError(errno.EINVAL,
- "Negative size not allowed")
- elif size < self.pos:
- self.pos = size
- self.buf = self.getvalue()[:size]
- def write(self, s):
- if self.closed:
- raise ValueError, "I/O operation on closed file"
- if not s: return
- if self.pos > self.len:
- self.buflist.append('\0'*(self.pos - self.len))
- self.len = self.pos
- newpos = self.pos + len(s)
- if self.pos < self.len:
- if self.buflist:
- self.buf = self.buf + string.joinfields(self.buflist, '')
- self.buflist = []
- self.buflist = [self.buf[:self.pos], s, self.buf[newpos:]]
- self.buf = ''
- if newpos > self.len:
- self.len = newpos
- else:
- self.buflist.append(s)
- self.len = newpos
- self.pos = newpos
- def writelines(self, list):
- self.write(string.joinfields(list, ''))
- def flush(self):
- if self.closed:
- raise ValueError, "I/O operation on closed file"
- def getvalue(self):
- if self.buflist:
- self.buf = self.buf + string.joinfields(self.buflist, '')
- self.buflist = []
- return self.buf
-
-
-# A little test suite
-
-def test():
- import sys
- if sys.argv[1:]:
- file = sys.argv[1]
- else:
- file = '/etc/passwd'
- lines = open(file, 'r').readlines()
- text = open(file, 'r').read()
- f = StringIO()
- for line in lines[:-2]:
- f.write(line)
- f.writelines(lines[-2:])
- if f.getvalue() != text:
- raise RuntimeError, 'write failed'
- length = f.tell()
- print 'File length =', length
- f.seek(len(lines[0]))
- f.write(lines[1])
- f.seek(0)
- print 'First line =', `f.readline()`
- here = f.tell()
- line = f.readline()
- print 'Second line =', `line`
- f.seek(-len(line), 1)
- line2 = f.read(len(line))
- if line != line2:
- raise RuntimeError, 'bad result after seek back'
- f.seek(len(line2), 1)
- list = f.readlines()
- line = list[-1]
- f.seek(f.tell() - len(line))
- line2 = f.read()
- if line != line2:
- raise RuntimeError, 'bad result after seek back from EOF'
- print 'Read', len(list), 'more lines'
- print 'File length =', f.tell()
- if f.tell() != length:
- raise RuntimeError, 'bad length'
- f.close()
-
-if __name__ == '__main__':
- test()
diff --git a/Lib/dos-8x3/stringol.py b/Lib/dos-8x3/stringol.py
deleted file mode 100644
index c3e6f6f..0000000
--- a/Lib/dos-8x3/stringol.py
+++ /dev/null
@@ -1,431 +0,0 @@
-# module 'string' -- A collection of string operations
-
-# Warning: most of the code you see here isn't normally used nowadays. With
-# Python 1.6, many of these functions are implemented as methods on the
-# standard string object. They used to be implemented by a built-in module
-# called strop, but strop is now obsolete itself.
-
-"""Common string manipulations.
-
-Public module variables:
-
-whitespace -- a string containing all characters considered whitespace
-lowercase -- a string containing all characters considered lowercase letters
-uppercase -- a string containing all characters considered uppercase letters
-letters -- a string containing all characters considered letters
-digits -- a string containing all characters considered decimal digits
-hexdigits -- a string containing all characters considered hexadecimal digits
-octdigits -- a string containing all characters considered octal digits
-
-"""
-
-# Some strings for ctype-style character classification
-whitespace = ' \t\n\r\v\f'
-lowercase = 'abcdefghijklmnopqrstuvwxyz'
-uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-letters = lowercase + uppercase
-digits = '0123456789'
-hexdigits = digits + 'abcdef' + 'ABCDEF'
-octdigits = '01234567'
-
-# Case conversion helpers
-_idmap = ''
-for i in range(256): _idmap = _idmap + chr(i)
-del i
-
-# Backward compatible names for exceptions
-index_error = ValueError
-atoi_error = ValueError
-atof_error = ValueError
-atol_error = ValueError
-
-# convert UPPER CASE letters to lower case
-def lower(s):
- """lower(s) -> string
-
- Return a copy of the string s converted to lowercase.
-
- """
- return s.lower()
-
-# Convert lower case letters to UPPER CASE
-def upper(s):
- """upper(s) -> string
-
- Return a copy of the string s converted to uppercase.
-
- """
- return s.upper()
-
-# Swap lower case letters and UPPER CASE
-def swapcase(s):
- """swapcase(s) -> string
-
- Return a copy of the string s with upper case characters
- converted to lowercase and vice versa.
-
- """
- return s.swapcase()
-
-# Strip leading and trailing tabs and spaces
-def strip(s):
- """strip(s) -> string
-
- Return a copy of the string s with leading and trailing
- whitespace removed.
-
- """
- return s.strip()
-
-# Strip leading tabs and spaces
-def lstrip(s):
- """lstrip(s) -> string
-
- Return a copy of the string s with leading whitespace removed.
-
- """
- return s.lstrip()
-
-# Strip trailing tabs and spaces
-def rstrip(s):
- """rstrip(s) -> string
-
- Return a copy of the string s with trailing whitespace
- removed.
-
- """
- return s.rstrip()
-
-
-# Split a string into a list of space/tab-separated words
-# NB: split(s) is NOT the same as splitfields(s, ' ')!
-def split(s, sep=None, maxsplit=0):
- """split(str [,sep [,maxsplit]]) -> list of strings
-
- Return a list of the words in the string s, using sep as the
- delimiter string. If maxsplit is nonzero, splits into at most
- maxsplit words If sep is not specified, any whitespace string
- is a separator. Maxsplit defaults to 0.
-
- (split and splitfields are synonymous)
-
- """
- return s.split(sep, maxsplit)
-splitfields = split
-
-# Join fields with optional separator
-def join(words, sep = ' '):
- """join(list [,sep]) -> string
-
- Return a string composed of the words in list, with
- intervening occurrences of sep. The default separator is a
- single space.
-
- (joinfields and join are synonymous)
-
- """
- return sep.join(words)
-joinfields = join
-
-# for a little bit of speed
-_apply = apply
-
-# Find substring, raise exception if not found
-def index(s, *args):
- """index(s, sub [,start [,end]]) -> int
-
- Like find but raises ValueError when the substring is not found.
-
- """
- return _apply(s.index, args)
-
-# Find last substring, raise exception if not found
-def rindex(s, *args):
- """rindex(s, sub [,start [,end]]) -> int
-
- Like rfind but raises ValueError when the substring is not found.
-
- """
- return _apply(s.rindex, args)
-
-# Count non-overlapping occurrences of substring
-def count(s, *args):
- """count(s, sub[, start[,end]]) -> int
-
- Return the number of occurrences of substring sub in string
- s[start:end]. Optional arguments start and end are
- interpreted as in slice notation.
-
- """
- return _apply(s.count, args)
-
-# Find substring, return -1 if not found
-def find(s, *args):
- """find(s, sub [,start [,end]]) -> in
-
- Return the lowest index in s where substring sub is found,
- such that sub is contained within s[start,end]. Optional
- arguments start and end are interpreted as in slice notation.
-
- Return -1 on failure.
-
- """
- return _apply(s.find, args)
-
-# Find last substring, return -1 if not found
-def rfind(s, *args):
- """rfind(s, sub [,start [,end]]) -> int
-
- Return the highest index in s where substring sub is found,
- such that sub is contained within s[start,end]. Optional
- arguments start and end are interpreted as in slice notation.
-
- Return -1 on failure.
-
- """
- return _apply(s.rfind, args)
-
-# for a bit of speed
-_float = float
-_int = int
-_long = long
-_StringType = type('')
-
-# Convert string to float
-def atof(s):
- """atof(s) -> float
-
- Return the floating point number represented by the string s.
-
- """
- if type(s) == _StringType:
- return _float(s)
- else:
- raise TypeError('argument 1: expected string, %s found' %
- type(s).__name__)
-
-# Convert string to integer
-def atoi(*args):
- """atoi(s [,base]) -> int
-
- Return the integer represented by the string s in the given
- base, which defaults to 10. The string s must consist of one
- or more digits, possibly preceded by a sign. If base is 0, it
- is chosen from the leading characters of s, 0 for octal, 0x or
- 0X for hexadecimal. If base is 16, a preceding 0x or 0X is
- accepted.
-
- """
- try:
- s = args[0]
- except IndexError:
- raise TypeError('function requires at least 1 argument: %d given' %
- len(args))
- # Don't catch type error resulting from too many arguments to int(). The
- # error message isn't compatible but the error type is, and this function
- # is complicated enough already.
- if type(s) == _StringType:
- return _apply(_int, args)
- else:
- raise TypeError('argument 1: expected string, %s found' %
- type(s).__name__)
-
-
-# Convert string to long integer
-def atol(*args):
- """atol(s [,base]) -> long
-
- Return the long integer represented by the string s in the
- given base, which defaults to 10. The string s must consist
- of one or more digits, possibly preceded by a sign. If base
- is 0, it is chosen from the leading characters of s, 0 for
- octal, 0x or 0X for hexadecimal. If base is 16, a preceding
- 0x or 0X is accepted. A trailing L or l is not accepted,
- unless base is 0.
-
- """
- try:
- s = args[0]
- except IndexError:
- raise TypeError('function requires at least 1 argument: %d given' %
- len(args))
- # Don't catch type error resulting from too many arguments to long(). The
- # error message isn't compatible but the error type is, and this function
- # is complicated enough already.
- if type(s) == _StringType:
- return _apply(_long, args)
- else:
- raise TypeError('argument 1: expected string, %s found' %
- type(s).__name__)
-
-
-# Left-justify a string
-def ljust(s, width):
- """ljust(s, width) -> string
-
- Return a left-justified version of s, in a field of the
- specified width, padded with spaces as needed. The string is
- never truncated.
-
- """
- n = width - len(s)
- if n <= 0: return s
- return s + ' '*n
-
-# Right-justify a string
-def rjust(s, width):
- """rjust(s, width) -> string
-
- Return a right-justified version of s, in a field of the
- specified width, padded with spaces as needed. The string is
- never truncated.
-
- """
- n = width - len(s)
- if n <= 0: return s
- return ' '*n + s
-
-# Center a string
-def center(s, width):
- """center(s, width) -> string
-
- Return a center version of s, in a field of the specified
- width. padded with spaces as needed. The string is never
- truncated.
-
- """
- n = width - len(s)
- if n <= 0: return s
- half = n/2
- if n%2 and width%2:
- # This ensures that center(center(s, i), j) = center(s, j)
- half = half+1
- return ' '*half + s + ' '*(n-half)
-
-# Zero-fill a number, e.g., (12, 3) --> '012' and (-3, 3) --> '-03'
-# Decadent feature: the argument may be a string or a number
-# (Use of this is deprecated; it should be a string as with ljust c.s.)
-def zfill(x, width):
- """zfill(x, width) -> string
-
- Pad a numeric string x with zeros on the left, to fill a field
- of the specified width. The string x is never truncated.
-
- """
- if type(x) == type(''): s = x
- else: s = `x`
- n = len(s)
- if n >= width: return s
- sign = ''
- if s[0] in ('-', '+'):
- sign, s = s[0], s[1:]
- return sign + '0'*(width-n) + s
-
-# Expand tabs in a string.
-# Doesn't take non-printing chars into account, but does understand \n.
-def expandtabs(s, tabsize=8):
- """expandtabs(s [,tabsize]) -> string
-
- Return a copy of the string s with all tab characters replaced
- by the appropriate number of spaces, depending on the current
- column, and the tabsize (default 8).
-
- """
- res = line = ''
- for c in s:
- if c == '\t':
- c = ' '*(tabsize - len(line) % tabsize)
- line = line + c
- if c == '\n':
- res = res + line
- line = ''
- return res + line
-
-# Character translation through look-up table.
-def translate(s, table, deletions=""):
- """translate(s,table [,deletechars]) -> string
-
- Return a copy of the string s, where all characters occurring
- in the optional argument deletechars are removed, and the
- remaining characters have been mapped through the given
- translation table, which must be a string of length 256.
-
- """
- return s.translate(table, deletions)
-
-# Capitalize a string, e.g. "aBc dEf" -> "Abc def".
-def capitalize(s):
- """capitalize(s) -> string
-
- Return a copy of the string s with only its first character
- capitalized.
-
- """
- return s.capitalize()
-
-# Capitalize the words in a string, e.g. " aBc dEf " -> "Abc Def".
-# See also regsub.capwords().
-def capwords(s, sep=None):
- """capwords(s, [sep]) -> string
-
- Split the argument into words using split, capitalize each
- word using capitalize, and join the capitalized words using
- join. Note that this replaces runs of whitespace characters by
- a single space.
-
- """
- return join(map(capitalize, s.split(sep)), sep or ' ')
-
-# Construct a translation string
-_idmapL = None
-def maketrans(fromstr, tostr):
- """maketrans(frm, to) -> string
-
- Return a translation table (a string of 256 bytes long)
- suitable for use in string.translate. The strings frm and to
- must be of the same length.
-
- """
- if len(fromstr) != len(tostr):
- raise ValueError, "maketrans arguments must have same length"
- global _idmapL
- if not _idmapL:
- _idmapL = map(None, _idmap)
- L = _idmapL[:]
- fromstr = map(ord, fromstr)
- for i in range(len(fromstr)):
- L[fromstr[i]] = tostr[i]
- return joinfields(L, "")
-
-# Substring replacement (global)
-def replace(s, old, new, maxsplit=0):
- """replace (str, old, new[, maxsplit]) -> string
-
- Return a copy of string str with all occurrences of substring
- old replaced by new. If the optional argument maxsplit is
- given, only the first maxsplit occurrences are replaced.
-
- """
- return s.replace(old, new, maxsplit)
-
-
-# XXX: transitional
-#
-# If string objects do not have methods, then we need to use the old string.py
-# library, which uses strop for many more things than just the few outlined
-# below.
-try:
- ''.upper
-except AttributeError:
- from stringold import *
-
-# Try importing optional built-in module "strop" -- if it exists,
-# it redefines some string operations that are 100-1000 times faster.
-# It also defines values for whitespace, lowercase and uppercase
-# that match <ctype.h>'s definitions.
-
-try:
- from strop import maketrans, lowercase, uppercase, whitespace
- letters = lowercase + uppercase
-except ImportError:
- pass # Use the original versions
diff --git a/Lib/dos-8x3/telnetli.py b/Lib/dos-8x3/telnetli.py
deleted file mode 100644
index dfd549e..0000000
--- a/Lib/dos-8x3/telnetli.py
+++ /dev/null
@@ -1,503 +0,0 @@
-"""TELNET client class.
-
-Based on RFC 854: TELNET Protocol Specification, by J. Postel and
-J. Reynolds
-
-Example:
-
->>> from telnetlib import Telnet
->>> tn = Telnet('www.python.org', 79) # connect to finger port
->>> tn.write('guido\r\n')
->>> print tn.read_all()
-Login Name TTY Idle When Where
-guido Guido van Rossum pts/2 <Dec 2 11:10> snag.cnri.reston..
-
->>>
-
-Note that read_all() won't read until eof -- it just reads some data
--- but it guarantees to read at least one byte unless EOF is hit.
-
-It is possible to pass a Telnet object to select.select() in order to
-wait until more data is available. Note that in this case,
-read_eager() may return '' even if there was data on the socket,
-because the protocol negotiation may have eaten the data. This is why
-EOFError is needed in some cases to distinguish between "no data" and
-"connection closed" (since the socket also appears ready for reading
-when it is closed).
-
-Bugs:
-- may hang when connection is slow in the middle of an IAC sequence
-
-To do:
-- option negotiation
-- timeout should be intrinsic to the connection object instead of an
- option on one of the read calls only
-
-"""
-
-
-# Imported modules
-import sys
-import socket
-import select
-import string
-
-# Tunable parameters
-DEBUGLEVEL = 0
-
-# Telnet protocol defaults
-TELNET_PORT = 23
-
-# Telnet protocol characters (don't change)
-IAC = chr(255) # "Interpret As Command"
-DONT = chr(254)
-DO = chr(253)
-WONT = chr(252)
-WILL = chr(251)
-theNULL = chr(0)
-
-
-class Telnet:
-
- """Telnet interface class.
-
- An instance of this class represents a connection to a telnet
- server. The instance is initially not connected; the open()
- method must be used to establish a connection. Alternatively, the
- host name and optional port number can be passed to the
- constructor, too.
-
- Don't try to reopen an already connected instance.
-
- This class has many read_*() methods. Note that some of them
- raise EOFError when the end of the connection is read, because
- they can return an empty string for other reasons. See the
- individual doc strings.
-
- read_until(expected, [timeout])
- Read until the expected string has been seen, or a timeout is
- hit (default is no timeout); may block.
-
- read_all()
- Read all data until EOF; may block.
-
- read_some()
- Read at least one byte or EOF; may block.
-
- read_very_eager()
- Read all data available already queued or on the socket,
- without blocking.
-
- read_eager()
- Read either data already queued or some data available on the
- socket, without blocking.
-
- read_lazy()
- Read all data in the raw queue (processing it first), without
- doing any socket I/O.
-
- read_very_lazy()
- Reads all data in the cooked queue, without doing any socket
- 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)
-
- def open(self, host, port=0):
- """Connect to a host.
-
- 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.
-
- """
- 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()
-
- def msg(self, msg, *args):
- """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 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.
-
- The higher it is, the more debug output you get (on sys.stdout).
-
- """
- self.debuglevel = debuglevel
-
- def close(self):
- """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
-
- def fileno(self):
- """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.
-
- Can block if the connection is blocked. May raise
- socket.error if the connection is closed.
-
- """
- if IAC in buffer:
- buffer = string.replace(buffer, IAC, IAC+IAC)
- self.msg("send %s", `buffer`)
- self.sock.send(buffer)
-
- 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()
-
- 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
-
- def read_some(self):
- """Read at least one byte of cooked data unless EOF is hit.
-
- 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
-
- 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()
-
- def read_eager(self):
- """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.
-
- """
- 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.
-
- """
- self.process_rawq()
- return self.read_very_lazy()
-
- def read_very_lazy(self):
- """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.
-
- """
- 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))
- self.sock.send(IAC + DONT + opt)
- 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
-
- def fill_rawq(self):
- """Fill raw queue from exactly one recv() system call.
-
- Block if no data is immediately available. Set self.eof when
- connection is closed.
-
- """
- if self.irawq >= len(self.rawq):
- self.rawq = ''
- self.irawq = 0
- # The buffer size should be fairly small so as to avoid quadratic
- # behavior in process_rawq() above
- buf = self.sock.recv(50)
- self.msg("recv %s", `buf`)
- self.eof = (not buf)
- self.rawq = self.rawq + buf
-
- def sock_avail(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."""
- if sys.platform == "win32":
- self.mt_interact()
- return
- 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 mt_interact(self):
- """Multithreaded version of interact()."""
- import thread
- thread.start_new_thread(self.listener, ())
- while 1:
- line = sys.stdin.readline()
- if not line:
- break
- self.write(line)
-
- def listener(self):
- """Helper for mt_interact() -- this executes in the other thread."""
- while 1:
- try:
- data = self.read_eager()
- except EOFError:
- print '*** Connection closed by remote host ***'
- return
- if data:
- sys.stdout.write(data)
- else:
- sys.stdout.flush()
-
- 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)
-
-
-def test():
- """Test program for telnetlib.
-
- Usage: python telnetlib.py [-d] ... [host [port]]
-
- Default host is localhost; default port is 23.
-
- """
- debuglevel = 0
- while sys.argv[1:] and sys.argv[1] == '-d':
- debuglevel = debuglevel+1
- del sys.argv[1]
- host = 'localhost'
- if 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')
- tn = Telnet()
- tn.set_debuglevel(debuglevel)
- tn.open(host, port)
- tn.interact()
- tn.close()
-
-if __name__ == '__main__':
- test()
diff --git a/Lib/dos-8x3/test_arr.py b/Lib/dos-8x3/test_arr.py
deleted file mode 100644
index fb451a9..0000000
--- a/Lib/dos-8x3/test_arr.py
+++ /dev/null
@@ -1,188 +0,0 @@
-#! /usr/bin/env python
-"""Test the arraymodule.
- Roger E. Masse
-"""
-import array
-from test_support import verbose, TESTFN, unlink, TestFailed
-
-def main():
-
- testtype('c', 'c')
-
- for type in (['b', 'h', 'i', 'l', 'f', 'd']):
- testtype(type, 1)
-
- unlink(TESTFN)
-
-
-def testoverflow(type, lowerLimit, upperLimit):
- # should not overflow assigning lower limit
- if verbose:
- print "overflow test: array(%s, [%s])" % (`type`, `lowerLimit`)
- try:
- a = array.array(type, [lowerLimit])
- except:
- raise TestFailed, "array(%s) overflowed assigning %s" %\
- (`type`, `lowerLimit`)
- # should overflow assigning less than lower limit
- if verbose:
- print "overflow test: array(%s, [%s])" % (`type`, `lowerLimit-1`)
- try:
- a = array.array(type, [lowerLimit-1])
- raise TestFailed, "array(%s) did not overflow assigning %s" %\
- (`type`, `lowerLimit-1`)
- except OverflowError:
- pass
- # should not overflow assigning upper limit
- if verbose:
- print "overflow test: array(%s, [%s])" % (`type`, `upperLimit`)
- try:
- a = array.array(type, [upperLimit])
- except:
- raise TestFailed, "array(%s) overflowed assigning %s" %\
- (`type`, `upperLimit`)
- # should overflow assigning more than upper limit
- if verbose:
- print "overflow test: array(%s, [%s])" % (`type`, `upperLimit+1`)
- try:
- a = array.array(type, [upperLimit+1])
- raise TestFailed, "array(%s) did not overflow assigning %s" %\
- (`type`, `upperLimit+1`)
- except OverflowError:
- pass
-
-
-
-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()`
-
- if type == 'c':
- a = array.array(type, "abcde")
- a[:-1] = a
- if a != array.array(type, "abcdee"):
- raise TestFailed, "array(%s) self-slice-assign (head)" % `type`
- a = array.array(type, "abcde")
- a[1:] = a
- if a != array.array(type, "aabcde"):
- raise TestFailed, "array(%s) self-slice-assign (tail)" % `type`
- a = array.array(type, "abcde")
- a[1:-1] = a
- if a != array.array(type, "aabcdee"):
- raise TestFailed, "array(%s) self-slice-assign (cntr)" % `type`
- if a.index("e") != 5:
- raise TestFailed, "array(%s) index-test" % `type`
- if a.count("a") != 2:
- raise TestFailed, "array(%s) count-test" % `type`
- a.remove("e")
- if a != array.array(type, "aabcde"):
- raise TestFailed, "array(%s) remove-test" % `type`
- if a.pop(0) != "a":
- raise TestFailed, "array(%s) pop-test" % `type`
- if a.pop(1) != "b":
- raise TestFailed, "array(%s) pop-test" % `type`
- a.extend(array.array(type, "xyz"))
- if a != array.array(type, "acdexyz"):
- raise TestFailed, "array(%s) extend-test" % `type`
- a.pop()
- a.pop()
- a.pop()
- x = a.pop()
- if x != 'e':
- raise TestFailed, "array(%s) pop-test" % `type`
- if a != array.array(type, "acd"):
- raise TestFailed, "array(%s) pop-test" % `type`
- a.reverse()
- if a != array.array(type, "dca"):
- raise TestFailed, "array(%s) reverse-test" % `type`
- else:
- a = array.array(type, [1, 2, 3, 4, 5])
- a[:-1] = a
- if a != array.array(type, [1, 2, 3, 4, 5, 5]):
- raise TestFailed, "array(%s) self-slice-assign (head)" % `type`
- a = array.array(type, [1, 2, 3, 4, 5])
- a[1:] = a
- if a != array.array(type, [1, 1, 2, 3, 4, 5]):
- raise TestFailed, "array(%s) self-slice-assign (tail)" % `type`
- a = array.array(type, [1, 2, 3, 4, 5])
- a[1:-1] = a
- if a != array.array(type, [1, 1, 2, 3, 4, 5, 5]):
- raise TestFailed, "array(%s) self-slice-assign (cntr)" % `type`
- if a.index(5) != 5:
- raise TestFailed, "array(%s) index-test" % `type`
- if a.count(1) != 2:
- raise TestFailed, "array(%s) count-test" % `type`
- a.remove(5)
- if a != array.array(type, [1, 1, 2, 3, 4, 5]):
- raise TestFailed, "array(%s) remove-test" % `type`
- if a.pop(0) != 1:
- raise TestFailed, "array(%s) pop-test" % `type`
- if a.pop(1) != 2:
- raise TestFailed, "array(%s) pop-test" % `type`
- a.extend(array.array(type, [7, 8, 9]))
- if a != array.array(type, [1, 3, 4, 5, 7, 8, 9]):
- raise TestFailed, "array(%s) extend-test" % `type`
- a.pop()
- a.pop()
- a.pop()
- x = a.pop()
- if x != 5:
- raise TestFailed, "array(%s) pop-test" % `type`
- if a != array.array(type, [1, 3, 4]):
- raise TestFailed, "array(%s) pop-test" % `type`
- a.reverse()
- if a != array.array(type, [4, 3, 1]):
- raise TestFailed, "array(%s) reverse-test" % `type`
-
- # test that overflow exceptions are raised as expected for assignment
- # to array of specific integral types
- from math import pow
- if type in ('b', 'h', 'i', 'l'):
- # check signed and unsigned versions
- a = array.array(type)
- signedLowerLimit = -1 * long(pow(2, a.itemsize * 8 - 1))
- signedUpperLimit = long(pow(2, a.itemsize * 8 - 1)) - 1L
- unsignedLowerLimit = 0
- unsignedUpperLimit = long(pow(2, a.itemsize * 8)) - 1L
- testoverflow(type, signedLowerLimit, signedUpperLimit)
- testoverflow(type.upper(), unsignedLowerLimit, unsignedUpperLimit)
-
-
-
-main()
-
diff --git a/Lib/dos-8x3/test_ate.py b/Lib/dos-8x3/test_ate.py
deleted file mode 100644
index 517610b..0000000
--- a/Lib/dos-8x3/test_ate.py
+++ /dev/null
@@ -1,24 +0,0 @@
-# Test the exit module
-from test_support import verbose
-import atexit
-
-def handler1():
- print "handler1"
-
-def handler2(*args, **kargs):
- print "handler2", args, kargs
-
-# save any exit functions that may have been registered as part of the
-# test framework
-_exithandlers = atexit._exithandlers
-atexit._exithandlers = []
-
-atexit.register(handler1)
-atexit.register(handler2)
-atexit.register(handler2, 7, kw="abc")
-
-# simulate exit behavior by calling atexit._run_exitfuncs directly...
-atexit._run_exitfuncs()
-
-# restore exit handlers
-atexit._exithandlers = _exithandlers
diff --git a/Lib/dos-8x3/test_aud.py b/Lib/dos-8x3/test_aud.py
deleted file mode 100755
index 900ec58..0000000
--- a/Lib/dos-8x3/test_aud.py
+++ /dev/null
@@ -1,264 +0,0 @@
-# Test audioop.
-import audioop
-from test_support import verbose
-
-def gendata1():
- return '\0\1\2'
-
-def gendata2():
- if verbose:
- print 'getsample'
- if audioop.getsample('\0\1', 2, 0) == 1:
- return '\0\0\0\1\0\2'
- else:
- return '\0\0\1\0\2\0'
-
-def gendata4():
- if verbose:
- 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'
- else:
- return '\0\0\0\0\1\0\0\0\2\0\0\0'
-
-def testmax(data):
- if verbose:
- 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
- return 1
-
-def testminmax(data):
- if verbose:
- 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
- return 1
-
-def testmaxpp(data):
- if verbose:
- 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
- return 1
-
-def testavg(data):
- if verbose:
- 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
- return 1
-
-def testavgpp(data):
- if verbose:
- 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
- return 1
-
-def testrms(data):
- if audioop.rms(data[0], 1) <> 1 or \
- audioop.rms(data[1], 2) <> 1 or \
- audioop.rms(data[2], 4) <> 1:
- return 0
- return 1
-
-def testcross(data):
- if verbose:
- 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
- return 1
-
-def testadd(data):
- if verbose:
- print 'add'
- data2 = []
- for d in data:
- str = ''
- for s in d:
- str = str + chr(ord(s)*2)
- data2.append(str)
- if audioop.add(data[0], data[0], 1) <> data2[0] or \
- audioop.add(data[1], data[1], 2) <> data2[1] or \
- audioop.add(data[2], data[2], 4) <> data2[2]:
- return 0
- return 1
-
-def testbias(data):
- if verbose:
- 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
- return 1
-
-def testlin2lin(data):
- if verbose:
- 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
- return 1
-
-def testadpcm2lin(data):
- # Very cursory test
- if audioop.adpcm2lin('\0\0', 1, None) <> ('\0\0\0\0', (0,0)):
- return 0
- return 1
-
-def testlin2adpcm(data):
- if verbose:
- print 'lin2adpcm'
- # Very cursory test
- if audioop.lin2adpcm('\0\0\0\0', 1, None) <> ('\0\0', (0,0)):
- return 0
- return 1
-
-def testlin2ulaw(data):
- if verbose:
- 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
- return 1
-
-def testulaw2lin(data):
- if verbose:
- print 'ulaw2lin'
- # Cursory
- d = audioop.lin2ulaw(data[0], 1)
- if audioop.ulaw2lin(d, 1) <> data[0]:
- return 0
- return 1
-
-def testmul(data):
- if verbose:
- print 'mul'
- data2 = []
- for d in data:
- str = ''
- for s in d:
- str = str + chr(ord(s)*2)
- data2.append(str)
- if audioop.mul(data[0], 1, 2) <> data2[0] or \
- audioop.mul(data[1],2, 2) <> data2[1] or \
- audioop.mul(data[2], 4, 2) <> data2[2]:
- return 0
- return 1
-
-def testratecv(data):
- if verbose:
- print 'ratecv'
- state = None
- d1, state = audioop.ratecv(data[0], 1, 1, 8000, 16000, state)
- d2, state = audioop.ratecv(data[0], 1, 1, 8000, 16000, state)
- if d1 + d2 != '\000\000\001\001\002\001\000\000\001\001\002':
- return 0
- return 1
-
-def testreverse(data):
- if verbose:
- print 'reverse'
- if audioop.reverse(data[0], 1) <> '\2\1\0':
- return 0
- return 1
-
-def testtomono(data):
- if verbose:
- print 'tomono'
- data2 = ''
- for d in data[0]:
- data2 = data2 + d + d
- if audioop.tomono(data2, 1, 0.5, 0.5) <> data[0]:
- return 0
- return 1
-
-def testtostereo(data):
- if verbose:
- print 'tostereo'
- data2 = ''
- for d in data[0]:
- data2 = data2 + d + d
- if audioop.tostereo(data[0], 1, 1, 1) <> data2:
- return 0
- return 1
-
-def testfindfactor(data):
- if verbose:
- print 'findfactor'
- if audioop.findfactor(data[1], data[1]) <> 1.0:
- return 0
- return 1
-
-def testfindfit(data):
- if verbose:
- print 'findfit'
- if audioop.findfit(data[1], data[1]) <> (0, 1.0):
- return 0
- return 1
-
-def testfindmax(data):
- if verbose:
- print 'findmax'
- if audioop.findmax(data[1], 1) <> 2:
- return 0
- return 1
-
-def testgetsample(data):
- if verbose:
- 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
- return 1
-
-def testone(name, data):
- try:
- func = eval('test'+name)
- except NameError:
- print 'No test found for audioop.'+name+'()'
- return
- try:
- rv = func(data)
- except 'xx':
- print 'Test FAILED for audioop.'+name+'() (with an exception)'
- return
- if not rv:
- print 'Test FAILED for audioop.'+name+'()'
-
-def testall():
- data = [gendata1(), gendata2(), gendata4()]
- names = dir(audioop)
- # We know there is a routine 'add'
- routines = []
- for n in names:
- if type(eval('audioop.'+n)) == type(audioop.add):
- routines.append(n)
- for n in routines:
- testone(n, data)
-testall()
diff --git a/Lib/dos-8x3/test_aug.py b/Lib/dos-8x3/test_aug.py
deleted file mode 100644
index a01195e..0000000
--- a/Lib/dos-8x3/test_aug.py
+++ /dev/null
@@ -1,232 +0,0 @@
-
-# Augmented assignment test.
-
-x = 2
-x += 1
-x *= 2
-x **= 2
-x -= 8
-x /= 2
-x %= 12
-x &= 2
-x |= 5
-x ^= 1
-
-print x
-
-x = [2]
-x[0] += 1
-x[0] *= 2
-x[0] **= 2
-x[0] -= 8
-x[0] /= 2
-x[0] %= 12
-x[0] &= 2
-x[0] |= 5
-x[0] ^= 1
-
-print x
-
-x = {0: 2}
-x[0] += 1
-x[0] *= 2
-x[0] **= 2
-x[0] -= 8
-x[0] /= 2
-x[0] %= 12
-x[0] &= 2
-x[0] |= 5
-x[0] ^= 1
-
-print x[0]
-
-x = [1,2]
-x += [3,4]
-x *= 2
-
-print x
-
-x = [1, 2, 3]
-y = x
-x[1:2] *= 2
-y[1:2] += [1]
-
-print x
-print x is y
-
-class aug_test:
- def __init__(self, value):
- self.val = value
- def __radd__(self, val):
- return self.val + val
- def __add__(self, val):
- return aug_test(self.val + val)
-
-
-class aug_test2(aug_test):
- def __iadd__(self, val):
- self.val = self.val + val
- return self
-
-class aug_test3(aug_test):
- def __iadd__(self, val):
- return aug_test3(self.val + val)
-
-x = aug_test(1)
-y = x
-x += 10
-
-print isinstance(x, aug_test)
-print y is not x
-print x.val
-
-x = aug_test2(2)
-y = x
-x += 10
-
-print y is x
-print x.val
-
-x = aug_test3(3)
-y = x
-x += 10
-
-print isinstance(x, aug_test3)
-print y is not x
-print x.val
-
-class testall:
-
- def __add__(self, val):
- print "__add__ called"
- def __radd__(self, val):
- print "__radd__ called"
- def __iadd__(self, val):
- print "__iadd__ called"
- return self
-
- def __sub__(self, val):
- print "__sub__ called"
- def __rsub__(self, val):
- print "__rsub__ called"
- def __isub__(self, val):
- print "__isub__ called"
- return self
-
- def __mul__(self, val):
- print "__mul__ called"
- def __rmul__(self, val):
- print "__rmul__ called"
- def __imul__(self, val):
- print "__imul__ called"
- return self
-
- def __div__(self, val):
- print "__div__ called"
- def __rdiv__(self, val):
- print "__rdiv__ called"
- def __idiv__(self, val):
- print "__idiv__ called"
- return self
-
- def __mod__(self, val):
- print "__mod__ called"
- def __rmod__(self, val):
- print "__rmod__ called"
- def __imod__(self, val):
- print "__imod__ called"
- return self
-
- def __pow__(self, val):
- print "__pow__ called"
- def __rpow__(self, val):
- print "__rpow__ called"
- def __ipow__(self, val):
- print "__ipow__ called"
- return self
-
- def __or__(self, val):
- print "__or__ called"
- def __ror__(self, val):
- print "__ror__ called"
- def __ior__(self, val):
- print "__ior__ called"
- return self
-
- def __and__(self, val):
- print "__and__ called"
- def __rand__(self, val):
- print "__rand__ called"
- def __iand__(self, val):
- print "__iand__ called"
- return self
-
- def __xor__(self, val):
- print "__xor__ called"
- def __rxor__(self, val):
- print "__rxor__ called"
- def __ixor__(self, val):
- print "__ixor__ called"
- return self
-
- def __rshift__(self, val):
- print "__rshift__ called"
- def __rrshift__(self, val):
- print "__rrshift__ called"
- def __irshift__(self, val):
- print "__irshift__ called"
- return self
-
- def __lshift__(self, val):
- print "__lshift__ called"
- def __rlshift__(self, val):
- print "__rlshift__ called"
- def __ilshift__(self, val):
- print "__ilshift__ called"
- return self
-
-x = testall()
-x + 1
-1 + x
-x += 1
-
-x - 1
-1 - x
-x -= 1
-
-x * 1
-1 * x
-x *= 1
-
-x / 1
-1 / x
-x /= 1
-
-x % 1
-1 % x
-x %= 1
-
-x ** 1
-1 ** x
-x **= 1
-
-x | 1
-1 | x
-x |= 1
-
-x & 1
-1 & x
-x &= 1
-
-x ^ 1
-1 ^ x
-x ^= 1
-
-x >> 1
-1 >> x
-x >>= 1
-
-x << 1
-1 << x
-x <<= 1
-
diff --git a/Lib/dos-8x3/test_bin.py b/Lib/dos-8x3/test_bin.py
deleted file mode 100644
index 52f817b..0000000
--- a/Lib/dos-8x3/test_bin.py
+++ /dev/null
@@ -1,112 +0,0 @@
-"""Test the binascii C module."""
-
-from test_support import verbose
-import binascii
-
-# Show module doc string
-print binascii.__doc__
-
-# Show module exceptions
-print binascii.Error
-print binascii.Incomplete
-
-# Check presence and display doc strings of all functions
-funcs = []
-for suffix in "base64", "hqx", "uu":
- prefixes = ["a2b_", "b2a_"]
- if suffix == "hqx":
- prefixes.extend(["crc_", "rlecode_", "rledecode_"])
- for prefix in prefixes:
- name = prefix + suffix
- funcs.append(getattr(binascii, name))
-for func in funcs:
- print "%-15s: %s" % (func.__name__, func.__doc__)
-
-# Create binary test data
-testdata = "The quick brown fox jumps over the lazy dog.\r\n"
-for i in range(256):
- # Be slow so we don't depend on other modules
- testdata = testdata + chr(i)
-testdata = testdata + "\r\nHello world.\n"
-
-# Test base64 with valid data
-print "base64 test"
-MAX_BASE64 = 57
-lines = []
-for i in range(0, len(testdata), MAX_BASE64):
- b = testdata[i:i+MAX_BASE64]
- a = binascii.b2a_base64(b)
- lines.append(a)
- print a,
-res = ""
-for line in lines:
- b = binascii.a2b_base64(line)
- res = res + b
-assert res == testdata
-
-# Test base64 with random invalid characters sprinkled throughout
-# (This requires a new version of binascii.)
-fillers = ""
-valid = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/"
-for i in range(256):
- c = chr(i)
- if c not in valid:
- fillers = fillers + c
-def addnoise(line):
- noise = fillers
- ratio = len(line) / len(noise)
- res = ""
- while line and noise:
- if len(line) / len(noise) > ratio:
- c, line = line[0], line[1:]
- else:
- c, noise = noise[0], noise[1:]
- res = res + c
- return res + noise + line
-res = ""
-for line in map(addnoise, lines):
- b = binascii.a2b_base64(line)
- res = res + b
-assert res == testdata
-
-# Test uu
-print "uu test"
-MAX_UU = 45
-lines = []
-for i in range(0, len(testdata), MAX_UU):
- b = testdata[i:i+MAX_UU]
- a = binascii.b2a_uu(b)
- lines.append(a)
- print a,
-res = ""
-for line in lines:
- b = binascii.a2b_uu(line)
- res = res + b
-assert res == testdata
-
-# Test crc32()
-crc = binascii.crc32("Test the CRC-32 of")
-crc = binascii.crc32(" this string.", crc)
-if crc != 1571220330:
- print "binascii.crc32() failed."
-
-# The hqx test is in test_binhex.py
-
-# test hexlification
-s = '{s\005\000\000\000worldi\002\000\000\000s\005\000\000\000helloi\001\000\000\0000'
-t = binascii.b2a_hex(s)
-u = binascii.a2b_hex(t)
-if s <> u:
- print 'binascii hexlification failed'
-try:
- binascii.a2b_hex(t[:-1])
-except TypeError:
- pass
-else:
- print 'expected TypeError not raised'
-try:
- binascii.a2b_hex(t[:-1] + 'q')
-except TypeError:
- pass
-else:
- print 'expected TypeError not raised'
diff --git a/Lib/dos-8x3/test_bsd.py b/Lib/dos-8x3/test_bsd.py
deleted file mode 100644
index e5780ea..0000000
--- a/Lib/dos-8x3/test_bsd.py
+++ /dev/null
@@ -1,74 +0,0 @@
-#! /usr/bin/env python
-"""Test script for the bsddb C module
- Roger E. Masse
-"""
-
-import os
-import bsddb
-import tempfile
-from test_support import verbose
-
-def test(openmethod, what):
-
- if verbose:
- print '\nTesting: ', what
-
- fname = tempfile.mktemp()
- f = openmethod(fname, 'c')
- if verbose:
- print 'creation...'
- f['0'] = ''
- f['a'] = 'Guido'
- f['b'] = 'van'
- f['c'] = 'Rossum'
- f['d'] = 'invented'
- f['f'] = 'Python'
- if verbose:
- 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!'
-
- f.sync()
- f.close()
- if verbose:
- print 'modification...'
- f = openmethod(fname, 'w')
- f['d'] = 'discovered'
-
- if verbose:
- print 'access...'
- for key in f.keys():
- word = f[key]
- if verbose:
- print word
-
- f.close()
- try:
- os.remove(fname)
- except os.error:
- pass
-
-types = [(bsddb.btopen, 'BTree'),
- (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
- ]
-
-for type in types:
- test(type[0], type[1])
diff --git a/Lib/dos-8x3/test_bui.py b/Lib/dos-8x3/test_bui.py
deleted file mode 100755
index 33fef8d..0000000
--- a/Lib/dos-8x3/test_bui.py
+++ /dev/null
@@ -1,13 +0,0 @@
-# Python test set -- part 4, built-in functions
-
-from test_support import *
-
-print '4. Built-in functions'
-
-print 'test_b1'
-unload('test_b1')
-import test_b1
-
-print 'test_b2'
-unload('test_b2')
-import test_b2
diff --git a/Lib/dos-8x3/test_cfg.py b/Lib/dos-8x3/test_cfg.py
deleted file mode 100644
index 4bdbc69..0000000
--- a/Lib/dos-8x3/test_cfg.py
+++ /dev/null
@@ -1,141 +0,0 @@
-import ConfigParser
-import StringIO
-
-def basic(src):
- print
- print "Testing basic accessors..."
- cf = ConfigParser.ConfigParser()
- sio = StringIO.StringIO(src)
- cf.readfp(sio)
- L = cf.sections()
- L.sort()
- print L
- for s in L:
- print "%s: %s" % (s, cf.options(s))
-
- # The use of spaces in the section names serves as a regression test for
- # SourceForge bug #115357.
- # http://sourceforge.net/bugs/?func=detailbug&group_id=5470&bug_id=115357
- print `cf.get('Foo Bar', 'foo', raw=1)`
- print `cf.get('Spacey Bar', 'foo', raw=1)`
- print `cf.get('Commented Bar', 'foo', raw=1)`
-
- if '__name__' in cf.options("Foo Bar"):
- print '__name__ "option" should not be exposed by the API!'
- else:
- print '__name__ "option" properly hidden by the API.'
-
-def interpolation(src):
- print
- print "Testing value interpolation..."
- cf = ConfigParser.ConfigParser({"getname": "%(__name__)s"})
- sio = StringIO.StringIO(src)
- cf.readfp(sio)
- print `cf.get("Foo", "getname")`
- print `cf.get("Foo", "bar")`
- print `cf.get("Foo", "bar9")`
- print `cf.get("Foo", "bar10")`
- expect_get_error(cf, ConfigParser.InterpolationDepthError, "Foo", "bar11")
-
-def parse_errors():
- print
- print "Testing for parsing errors..."
- expect_parse_error(ConfigParser.ParsingError,
- """[Foo]\n extra-spaces: splat\n""")
- expect_parse_error(ConfigParser.ParsingError,
- """[Foo]\n extra-spaces= splat\n""")
- expect_parse_error(ConfigParser.ParsingError,
- """[Foo]\noption-without-value\n""")
- expect_parse_error(ConfigParser.ParsingError,
- """[Foo]\n:value-without-option-name\n""")
- expect_parse_error(ConfigParser.ParsingError,
- """[Foo]\n=value-without-option-name\n""")
- expect_parse_error(ConfigParser.MissingSectionHeaderError,
- """No Section!\n""")
-
-def query_errors():
- print
- print "Testing query interface..."
- cf = ConfigParser.ConfigParser()
- print cf.sections()
- print "Has section 'Foo'?", cf.has_section("Foo")
- try:
- cf.options("Foo")
- except ConfigParser.NoSectionError, e:
- print "Caught expected NoSectionError:", e
- else:
- print "Failed to catch expected NoSectionError from options()"
- try:
- cf.set("foo", "bar", "value")
- except ConfigParser.NoSectionError, e:
- print "Caught expected NoSectionError:", e
- else:
- print "Failed to catch expected NoSectionError from set()"
- expect_get_error(cf, ConfigParser.NoSectionError, "foo", "bar")
- cf.add_section("foo")
- expect_get_error(cf, ConfigParser.NoOptionError, "foo", "bar")
-
-def weird_errors():
- print
- print "Testing miscellaneous error conditions..."
- cf = ConfigParser.ConfigParser()
- cf.add_section("Foo")
- try:
- cf.add_section("Foo")
- except ConfigParser.DuplicateSectionError, e:
- print "Caught expected DuplicateSectionError:", e
- else:
- print "Failed to catch expected DuplicateSectionError"
-
-def expect_get_error(cf, exctype, section, option, raw=0):
- try:
- cf.get(section, option, raw=raw)
- except exctype, e:
- print "Caught expected", exctype.__name__, ":"
- print e
- else:
- print "Failed to catch expected", exctype.__name__
-
-def expect_parse_error(exctype, src):
- cf = ConfigParser.ConfigParser()
- sio = StringIO.StringIO(src)
- try:
- cf.readfp(sio)
- except exctype, e:
- print "Caught expected exception:", e
- else:
- print "Failed to catch expected", exctype.__name__
-
-basic(r"""
-[Foo Bar]
-foo=bar
-[Spacey Bar]
-foo = bar
-[Commented Bar]
-foo: bar ; comment
-""")
-interpolation(r"""
-[Foo]
-bar=something %(with1)s interpolation (1 step)
-bar9=something %(with9)s lots of interpolation (9 steps)
-bar10=something %(with10)s lots of interpolation (10 steps)
-bar11=something %(with11)s lots of interpolation (11 steps)
-with11=%(with10)s
-with10=%(with9)s
-with9=%(with8)s
-with8=%(with7)s
-with7=%(with6)s
-with6=%(with5)s
-with5=%(with4)s
-with4=%(with3)s
-with3=%(with2)s
-with2=%(with1)s
-with1=with
-
-[Mutual Recursion]
-foo=%(bar)s
-bar=%(foo)s
-""")
-parse_errors()
-query_errors()
-weird_errors()
diff --git a/Lib/dos-8x3/test_cla.py b/Lib/dos-8x3/test_cla.py
deleted file mode 100644
index 43c1d3b..0000000
--- a/Lib/dos-8x3/test_cla.py
+++ /dev/null
@@ -1,219 +0,0 @@
-"Test the functionality of Python classes implementing operators."
-
-
-testmeths = [
-
-# Binary operations
- "add",
- "radd",
- "sub",
- "rsub",
- "mul",
- "rmul",
- "div",
- "rdiv",
- "mod",
- "rmod",
- "divmod",
- "rdivmod",
- "pow",
- "rpow",
- "rshift",
- "rrshift",
- "lshift",
- "rlshift",
- "and",
- "rand",
- "or",
- "ror",
- "xor",
- "rxor",
-
-# List/dict operations
- "contains",
- "getitem",
- "getslice",
- "setitem",
- "setslice",
- "delitem",
- "delslice",
-
-# Unary operations
- "neg",
- "pos",
- "abs",
- "int",
- "long",
- "float",
- "oct",
- "hex",
-
-# generic operations
- "init",
- "del",
- ]
-
-# These need to return something other than None
-# "coerce",
-# "hash",
-# "str",
-# "repr",
-
-# These are separate because they can influence the test of other methods.
-# "getattr",
-# "setattr",
-# "delattr",
-
-class AllTests:
- def __coerce__(self, *args):
- print "__coerce__:", args
- return (self,) + args
-
- def __hash__(self, *args):
- print "__hash__:", args
- return hash(id(self))
-
- def __str__(self, *args):
- print "__str__:", args
- return "AllTests"
-
- def __repr__(self, *args):
- print "__repr__:", args
- return "AllTests"
-
- def __cmp__(self, *args):
- print "__cmp__:", args
- return 0
-
-for method in testmeths:
- exec("""def __%(method)s__(self, *args):
- print "__%(method)s__:", args
-"""%locals(), AllTests.__dict__);
-
-# this also tests __init__ of course.
-testme = AllTests()
-
-# Binary operations
-
-testme + 1
-1 + testme
-
-testme - 1
-1 - testme
-
-testme * 1
-1 * testme
-
-testme / 1
-1 / testme
-
-testme % 1
-1 % testme
-
-divmod(testme,1)
-divmod(1, testme)
-
-testme ** 1
-1 ** testme
-
-testme >> 1
-1 >> testme
-
-testme << 1
-1 << testme
-
-testme & 1
-1 & testme
-
-testme | 1
-1 | testme
-
-testme ^ 1
-1 ^ testme
-
-
-# List/dict operations
-
-1 in testme
-
-testme[1]
-testme[1] = 1
-del testme[1]
-
-testme[:42]
-testme[:42] = "The Answer"
-del testme[:42]
-
-testme[2:1024:10]
-testme[2:1024:10] = "A lot"
-del testme[2:1024:10]
-
-testme[:42, ..., :24:, 24, 100]
-testme[:42, ..., :24:, 24, 100] = "Strange"
-del testme[:42, ..., :24:, 24, 100]
-
-
-# Now remove the slice hooks to see if converting normal slices to slice
-# object works.
-
-del AllTests.__getslice__
-del AllTests.__setslice__
-del AllTests.__delslice__
-
-testme[:42]
-testme[:42] = "The Answer"
-del testme[:42]
-
-
-# Unary operations
-
--testme
-+testme
-abs(testme)
-int(testme)
-long(testme)
-float(testme)
-oct(testme)
-hex(testme)
-
-
-# And the rest...
-
-hash(testme)
-repr(testme)
-str(testme)
-
-testme == 1
-testme < 1
-testme > 1
-testme <> 1
-testme != 1
-1 == testme
-1 < testme
-1 > testme
-1 <> testme
-1 != testme
-
-# This test has to be last (duh.)
-
-del testme
-
-
-# Interfering tests
-
-class ExtraTests:
- def __getattr__(self, *args):
- print "__getattr__:", args
- return "SomeVal"
-
- def __setattr__(self, *args):
- print "__setattr__:", args
-
- def __delattr__(self, *args):
- print "__delattr__:", args
-
-testme = ExtraTests()
-testme.spam
-testme.eggs = "spam, spam, spam and ham"
-del testme.cardinal
-
diff --git a/Lib/dos-8x3/test_cma.py b/Lib/dos-8x3/test_cma.py
deleted file mode 100644
index 509c739..0000000
--- a/Lib/dos-8x3/test_cma.py
+++ /dev/null
@@ -1,35 +0,0 @@
-#! /usr/bin/env python
-""" Simple test script for cmathmodule.c
- Roger E. Masse
-"""
-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}
-
-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))
-
-p = cmath.pi
-e = cmath.e
-if verbose:
- print 'PI = ', abs(p)
- print 'E = ', abs(e)
diff --git a/Lib/dos-8x3/test_com.py b/Lib/dos-8x3/test_com.py
deleted file mode 100644
index 8905864..0000000
--- a/Lib/dos-8x3/test_com.py
+++ /dev/null
@@ -1,16 +0,0 @@
-from test_support import verbose, TestFailed
-
-if verbose:
- print 'Running test on duplicate arguments'
-
-try:
- exec('def f(a, a): pass')
- raise TestFailed, "duplicate arguments"
-except SyntaxError:
- pass
-
-try:
- exec('def f(a = 0, a = 1): pass')
- raise TestFailed, "duplicate keyword arguments"
-except SyntaxError:
- pass
diff --git a/Lib/dos-8x3/test_con.py b/Lib/dos-8x3/test_con.py
deleted file mode 100644
index 355135f..0000000
--- a/Lib/dos-8x3/test_con.py
+++ /dev/null
@@ -1,168 +0,0 @@
-from test_support import TestFailed
-
-class base_set:
-
- def __init__(self, el):
- self.el = el
-
-class set(base_set):
-
- def __contains__(self, el):
- return self.el == el
-
-class seq(base_set):
-
- def __getitem__(self, n):
- return [self.el][n]
-
-def check(ok, *args):
- if not ok:
- raise TestFailed, " ".join(map(str, args))
-
-a = base_set(1)
-b = set(1)
-c = seq(1)
-
-check(1 in b, "1 not in set(1)")
-check(0 not in b, "0 in set(1)")
-check(1 in c, "1 not in seq(1)")
-check(0 not in c, "0 in seq(1)")
-
-try:
- 1 in a
- check(0, "in base_set did not raise error")
-except AttributeError:
- pass
-
-try:
- 1 not in a
- check(0, "not in base_set did not raise error")
-except AttributeError:
- pass
-
-# Test char in string
-
-check('c' in 'abc', "'c' not in 'abc'")
-check('d' not in 'abc', "'d' in 'abc'")
-
-try:
- '' in 'abc'
- check(0, "'' in 'abc' did not raise error")
-except TypeError:
- pass
-
-try:
- 'ab' in 'abc'
- check(0, "'ab' in 'abc' did not raise error")
-except TypeError:
- pass
-
-try:
- None in 'abc'
- check(0, "None in 'abc' did not raise error")
-except TypeError:
- pass
-
-# Test char in Unicode
-
-check('c' in u'abc', "'c' not in u'abc'")
-check('d' not in u'abc', "'d' in u'abc'")
-
-try:
- '' in u'abc'
- check(0, "'' in u'abc' did not raise error")
-except TypeError:
- pass
-
-try:
- 'ab' in u'abc'
- check(0, "'ab' in u'abc' did not raise error")
-except TypeError:
- pass
-
-try:
- None in u'abc'
- check(0, "None in u'abc' did not raise error")
-except TypeError:
- pass
-
-# Test Unicode char in Unicode
-
-check(u'c' in u'abc', "u'c' not in u'abc'")
-check(u'd' not in u'abc', "u'd' in u'abc'")
-
-try:
- u'' in u'abc'
- check(0, "u'' in u'abc' did not raise error")
-except TypeError:
- pass
-
-try:
- u'ab' in u'abc'
- check(0, "u'ab' in u'abc' did not raise error")
-except TypeError:
- pass
-
-# Test Unicode char in string
-
-check(u'c' in 'abc', "u'c' not in 'abc'")
-check(u'd' not in 'abc', "u'd' in 'abc'")
-
-try:
- u'' in 'abc'
- check(0, "u'' in 'abc' did not raise error")
-except TypeError:
- pass
-
-try:
- u'ab' in 'abc'
- check(0, "u'ab' in 'abc' did not raise error")
-except TypeError:
- pass
-
-# A collection of tests on builtin sequence types
-a = range(10)
-for i in a:
- check(i in a, "%s not in %s" % (`i`, `a`))
-check(16 not in a, "16 not in %s" % `a`)
-check(a not in a, "%s not in %s" % (`a`, `a`))
-
-a = tuple(a)
-for i in a:
- check(i in a, "%s not in %s" % (`i`, `a`))
-check(16 not in a, "16 not in %s" % `a`)
-check(a not in a, "%s not in %s" % (`a`, `a`))
-
-class Deviant1:
- """Behaves strangely when compared
-
- This class is designed to make sure that the contains code
- works when the list is modified during the check.
- """
-
- aList = range(15)
-
- def __cmp__(self, other):
- if other == 12:
- self.aList.remove(12)
- self.aList.remove(13)
- self.aList.remove(14)
- return 1
-
-check(Deviant1() not in Deviant1.aList, "Deviant1 failed")
-
-class Deviant2:
- """Behaves strangely when compared
-
- This class raises an exception during comparison. That in
- turn causes the comparison to fail with a TypeError.
- """
-
- def __cmp__(self, other):
- if other == 4:
- raise RuntimeError, "gotcha"
-
-try:
- check(Deviant2() not in a, "oops")
-except TypeError:
- pass
diff --git a/Lib/dos-8x3/test_coo.py b/Lib/dos-8x3/test_coo.py
deleted file mode 100644
index a275cf2..0000000
--- a/Lib/dos-8x3/test_coo.py
+++ /dev/null
@@ -1,40 +0,0 @@
-
-# Simple test suite for Cookie.py
-
-import Cookie
-
-# Currently this only tests SimpleCookie
-
-cases = [
- ('chips=ahoy; vienna=finger', {'chips':'ahoy', 'vienna':'finger'}),
- ('keebler="E=mc2; L=\\"Loves\\"; fudge=\\012;";',
- {'keebler' : 'E=mc2; L="Loves"; fudge=\012;'}),
- ]
-
-for data, dict in cases:
- C = Cookie.SimpleCookie() ; C.load(data)
- print repr(C)
- print str(C)
- for k, v in dict.items():
- print ' ', k, repr( C[k].value ), repr(v)
- assert C[k].value == v
- print C[k]
-
-C = Cookie.SimpleCookie()
-C.load('Customer="WILE_E_COYOTE"; Version=1; Path=/acme')
-
-assert C['Customer'].value == 'WILE_E_COYOTE'
-assert C['Customer']['version'] == '1'
-assert C['Customer']['path'] == '/acme'
-
-print C.output(['path'])
-print C.js_output()
-print C.js_output(['path'])
-
-# Try cookie with quoted meta-data
-C = Cookie.SimpleCookie()
-C.load('Customer="WILE_E_COYOTE"; Version="1"; Path="/acme"')
-assert C['Customer'].value == 'WILE_E_COYOTE'
-assert C['Customer']['version'] == '1'
-assert C['Customer']['path'] == '/acme'
-
diff --git a/Lib/dos-8x3/test_cop.py b/Lib/dos-8x3/test_cop.py
deleted file mode 100644
index 0324d92..0000000
--- a/Lib/dos-8x3/test_cop.py
+++ /dev/null
@@ -1,35 +0,0 @@
-import copy_reg
-
-class C:
- pass
-
-
-try:
- copy_reg.pickle(C, None, None)
-except TypeError, e:
- print "Caught expected TypeError:"
- print e
-else:
- print "Failed to catch expected TypeError when registering a class type."
-
-
-print
-try:
- copy_reg.pickle(type(1), "not a callable")
-except TypeError, e:
- print "Caught expected TypeError:"
- print e
-else:
- print "Failed to catch TypeError " \
- "when registering a non-callable reduction function."
-
-
-print
-try:
- copy_reg.pickle(type(1), int, "not a callable")
-except TypeError, e:
- print "Caught expected TypeError:"
- print e
-else:
- print "Failed to catch TypeError " \
- "when registering a non-callable constructor."
diff --git a/Lib/dos-8x3/test_cpi.py b/Lib/dos-8x3/test_cpi.py
deleted file mode 100644
index f2aa0fe..0000000
--- a/Lib/dos-8x3/test_cpi.py
+++ /dev/null
@@ -1,5 +0,0 @@
-# Test the cPickle module
-
-import cPickle
-import test_pickle
-test_pickle.dotest(cPickle)
diff --git a/Lib/dos-8x3/test_cry.py b/Lib/dos-8x3/test_cry.py
deleted file mode 100644
index 0685c95..0000000
--- a/Lib/dos-8x3/test_cry.py
+++ /dev/null
@@ -1,11 +0,0 @@
-#! /usr/bin/env python
-"""Simple test script for cryptmodule.c
- Roger E. Masse
-"""
-
-from test_support import verbose
-import crypt
-
-c = crypt.crypt('mypassword', 'ab')
-if verbose:
- print 'Test encryption: ', c
diff --git a/Lib/dos-8x3/test_dos.py b/Lib/dos-8x3/test_dos.py
deleted file mode 100644
index ffa3ef7..0000000
--- a/Lib/dos-8x3/test_dos.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import dospath
-import string
-import os
-
-errors = 0
-
-def tester(fn, wantResult):
- fn = string.replace(fn, "\\", "\\\\")
- gotResult = eval(fn)
- if wantResult != gotResult:
- print "error!"
- print "evaluated: " + str(fn)
- print "should be: " + str(wantResult)
- print " returned: " + str(gotResult)
- print ""
- global errors
- errors = errors + 1
-
-tester('dospath.splitdrive("c:\\foo\\bar")', ('c:', '\\foo\\bar'))
-tester('dospath.splitdrive("c:/foo/bar")', ('c:', '/foo/bar'))
-
-tester('dospath.split("c:\\foo\\bar")', ('c:\\foo', 'bar'))
-tester('dospath.split("\\\\conky\\mountpoint\\foo\\bar")', ('\\\\conky\\mountpoint\\foo', 'bar'))
-
-tester('dospath.split("c:\\")', ('c:\\', ''))
-tester('dospath.split("\\\\conky\\mountpoint\\")', ('\\\\conky\\mountpoint', ''))
-
-tester('dospath.split("c:/")', ('c:/', ''))
-tester('dospath.split("//conky/mountpoint/")', ('//conky/mountpoint', ''))
-
-tester('dospath.isabs("c:\\")', 1)
-tester('dospath.isabs("\\\\conky\\mountpoint\\")', 1)
-tester('dospath.isabs("\\foo")', 1)
-tester('dospath.isabs("\\foo\\bar")', 1)
-
-tester('dospath.abspath("C:\\")', "C:\\")
-
-tester('dospath.commonprefix(["/home/swenson/spam", "/home/swen/spam"])',
- "/home/swen")
-tester('dospath.commonprefix(["\\home\\swen\\spam", "\\home\\swen\\eggs"])',
- "\\home\\swen\\")
-tester('dospath.commonprefix(["/home/swen/spam", "/home/swen/spam"])',
- "/home/swen/spam")
-
-if errors:
- print str(errors) + " errors."
-else:
- print "No errors. Thank your lucky stars."
-
diff --git a/Lib/dos-8x3/test_err.py b/Lib/dos-8x3/test_err.py
deleted file mode 100644
index cb1e729..0000000
--- a/Lib/dos-8x3/test_err.py
+++ /dev/null
@@ -1,49 +0,0 @@
-#! /usr/bin/env python
-"""Test the errno module
- Roger E. Masse
-"""
-
-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']
-
-#
-# This is is a wee bit bogus since the module only conditionally adds
-# errno constants if they have been defined by errno.h However, this
-# test seems to work on SGI, Sparc & intel Solaris, and linux.
-#
-for error in errors:
- try:
- a = getattr(errno, error)
- except AttributeError:
- if verbose:
- print '%s: not found' % error
- else:
- if verbose:
- print '%s: %d' % (error, a)
diff --git a/Lib/dos-8x3/test_exc.py b/Lib/dos-8x3/test_exc.py
deleted file mode 100755
index 076f470..0000000
--- a/Lib/dos-8x3/test_exc.py
+++ /dev/null
@@ -1,170 +0,0 @@
-# Python test set -- part 5, built-in exceptions
-
-from test_support import *
-from types import ClassType
-
-print '5. Built-in exceptions'
-# XXX This is not really enough, each *operation* should be tested!
-
-def test_raise_catch(exc):
- try:
- raise exc, "spam"
- except exc, err:
- buf = str(err)
- try:
- raise exc("spam")
- except exc, err:
- buf = str(err)
- print buf
-
-def r(thing):
- test_raise_catch(thing)
- if isinstance(thing, ClassType):
- print thing.__name__
- else:
- print thing
-
-r(AttributeError)
-import sys
-try: x = sys.undefined_attribute
-except AttributeError: pass
-
-r(EOFError)
-import sys
-fp = open(TESTFN, 'w')
-fp.close()
-fp = open(TESTFN, 'r')
-savestdin = sys.stdin
-try:
- try:
- sys.stdin = fp
- x = raw_input()
- except EOFError:
- pass
-finally:
- sys.stdin = savestdin
- fp.close()
-
-r(IOError)
-try: open('this file does not exist', 'r')
-except IOError: pass
-
-r(ImportError)
-try: import undefined_module
-except ImportError: pass
-
-r(IndexError)
-x = []
-try: a = x[10]
-except IndexError: pass
-
-r(KeyError)
-x = {}
-try: a = x['key']
-except KeyError: pass
-
-r(KeyboardInterrupt)
-print '(not testable in a script)'
-
-r(MemoryError)
-print '(not safe to test)'
-
-r(NameError)
-try: x = undefined_variable
-except NameError: pass
-
-r(OverflowError)
-x = 1
-try:
- while 1: x = x+x
-except OverflowError: pass
-
-r(RuntimeError)
-print '(not used any more?)'
-
-r(SyntaxError)
-try: exec '/\n'
-except SyntaxError: pass
-
-# make sure the right exception message is raised for each of these
-# code fragments:
-
-def ckmsg(src, msg):
- try:
- compile(src, '<fragment>', 'exec')
- except SyntaxError, e:
- print e.msg
- if e.msg == msg:
- print "ok"
- else:
- print "expected:", msg
- else:
- print "failed to get expected SyntaxError"
-
-s = '''\
-while 1:
- try:
- continue
- except:
- pass
-'''
-ckmsg(s, "'continue' not supported inside 'try' clause")
-s = '''\
-while 1:
- try:
- continue
- finally:
- pass
-'''
-ckmsg(s, "'continue' not supported inside 'try' clause")
-s = '''\
-while 1:
- try:
- if 1:
- continue
- finally:
- pass
-'''
-ckmsg(s, "'continue' not supported inside 'try' clause")
-s = '''\
-try:
- continue
-except:
- pass
-'''
-ckmsg(s, "'continue' not properly in loop")
-ckmsg("continue\n", "'continue' not properly in loop")
-
-r(IndentationError)
-
-r(TabError)
-# can only be tested under -tt, and is the only test for -tt
-#try: compile("try:\n\t1/0\n \t1/0\nfinally:\n pass\n", '<string>', 'exec')
-#except TabError: pass
-#else: raise TestFailed
-
-r(SystemError)
-print '(hard to reproduce)'
-
-r(SystemExit)
-import sys
-try: sys.exit(0)
-except SystemExit: pass
-
-r(TypeError)
-try: [] + ()
-except TypeError: pass
-
-r(ValueError)
-try: x = chr(10000)
-except ValueError: pass
-
-r(ZeroDivisionError)
-try: x = 1/0
-except ZeroDivisionError: pass
-
-r(Exception)
-try: x = 1/0
-except Exception, e: pass
-
-unlink(TESTFN)
diff --git a/Lib/dos-8x3/test_ext.py b/Lib/dos-8x3/test_ext.py
deleted file mode 100644
index de2312b..0000000
--- a/Lib/dos-8x3/test_ext.py
+++ /dev/null
@@ -1,146 +0,0 @@
-from UserList import UserList
-
-def f(*a, **k):
- print a, k
-
-def g(x, *y, **z):
- print x, y, z
-
-def h(j=1, a=2, h=3):
- print j, a, h
-
-f()
-f(1)
-f(1, 2)
-f(1, 2, 3)
-
-f(1, 2, 3, *(4, 5))
-f(1, 2, 3, *[4, 5])
-f(1, 2, 3, *UserList([4, 5]))
-f(1, 2, 3, **{'a':4, 'b':5})
-f(1, 2, 3, *(4, 5), **{'a':6, 'b':7})
-f(1, 2, 3, x=4, y=5, *(6, 7), **{'a':8, 'b':9})
-
-try:
- g()
-except TypeError, err:
- print "TypeError:", err
-else:
- print "should raise TypeError: not enough arguments; expected 1, got 0"
-
-try:
- g(*())
-except TypeError, err:
- print "TypeError:", err
-else:
- print "should raise TypeError: not enough arguments; expected 1, got 0"
-
-try:
- g(*(), **{})
-except TypeError, err:
- print "TypeError:", err
-else:
- print "should raise TypeError: not enough arguments; expected 1, got 0"
-
-g(1)
-g(1, 2)
-g(1, 2, 3)
-g(1, 2, 3, *(4, 5))
-class Nothing: pass
-try:
- g(*Nothing())
-except AttributeError, attr:
- pass
-else:
- print "should raise AttributeError: __len__"
-
-class Nothing:
- def __len__(self):
- return 5
-try:
- g(*Nothing())
-except AttributeError, attr:
- pass
-else:
- print "should raise AttributeError: __getitem__"
-
-class Nothing:
- def __len__(self):
- return 5
- def __getitem__(self, i):
- if i < 3:
- return i
- else:
- raise IndexError, i
-g(*Nothing())
-
-# make sure the function call doesn't stomp on the dictionary?
-d = {'a': 1, 'b': 2, 'c': 3}
-d2 = d.copy()
-assert d == d2
-g(1, d=4, **d)
-print d
-print d2
-assert d == d2, "function call modified dictionary"
-
-# what about willful misconduct?
-def saboteur(**kw):
- kw['x'] = locals() # yields a cyclic kw
- return kw
-d = {}
-kw = saboteur(a=1, **d)
-assert d == {}
-# break the cycle
-del kw['x']
-
-try:
- g(1, 2, 3, **{'x':4, 'y':5})
-except TypeError, err:
- print err
-else:
- print "should raise TypeError: keyword parameter redefined"
-
-try:
- g(1, 2, 3, a=4, b=5, *(6, 7), **{'a':8, 'b':9})
-except TypeError, err:
- print err
-else:
- print "should raise TypeError: keyword parameter redefined"
-
-try:
- f(**{1:2})
-except TypeError, err:
- print err
-else:
- print "should raise TypeError: keywords must be strings"
-
-try:
- h(**{'e': 2})
-except TypeError, err:
- print err
-else:
- print "should raise TypeError: unexpected keyword argument: e"
-
-try:
- h(*h)
-except TypeError, err:
- print err
-else:
- print "should raise TypeError: * argument must be a tuple"
-
-try:
- h(**h)
-except TypeError, err:
- print err
-else:
- print "should raise TypeError: ** argument must be a dictionary"
-
-def f2(*a, **b):
- return a, b
-
-d = {}
-for i in range(512):
- key = 'k%d' % i
- d[key] = i
-a, b = f2(1, *(2, 3), **d)
-print len(a), len(b), b == d
diff --git a/Lib/dos-8x3/test_fcn.py b/Lib/dos-8x3/test_fcn.py
deleted file mode 100644
index a1da0dd..0000000
--- a/Lib/dos-8x3/test_fcn.py
+++ /dev/null
@@ -1,36 +0,0 @@
-#! /usr/bin/env python
-"""Test program for the fcntl C module.
- Roger E. Masse
-"""
-import struct
-import fcntl
-import FCNTL
-import os, sys
-from test_support import verbose
-
-filename = '/tmp/delete-me'
-
-# the example from the library docs
-f = open(filename,'w')
-rv = fcntl.fcntl(f.fileno(), FCNTL.F_SETFL, os.O_NONBLOCK)
-if verbose:
- print 'Status from fnctl with O_NONBLOCK: ', rv
-
-if sys.platform in ('netbsd1', 'Darwin1.2',
- 'freebsd2', 'freebsd3', 'freebsd4', 'freebsd5',
- 'bsdos2', 'bsdos3', 'bsdos4',
- 'openbsd', 'openbsd2'):
- lockdata = struct.pack('lxxxxlxxxxlhh', 0, 0, 0, FCNTL.F_WRLCK, 0)
-elif sys.platform in ['aix3', 'aix4', 'hp-uxB']:
- lockdata = struct.pack('hhlllii', FCNTL.F_WRLCK, 0, 0, 0, 0, 0, 0)
-else:
- lockdata = struct.pack('hhllhh', FCNTL.F_WRLCK, 0, 0, 0, 0, 0)
-if verbose:
- print 'struct.pack: ', `lockdata`
-
-rv = fcntl.fcntl(f.fileno(), FCNTL.F_SETLKW, lockdata)
-if verbose:
- print 'String from fcntl with F_SETLKW: ', `rv`
-
-f.close()
-os.unlink(filename)
diff --git a/Lib/dos-8x3/test_fil.py b/Lib/dos-8x3/test_fil.py
deleted file mode 100644
index 4ad5c95..0000000
--- a/Lib/dos-8x3/test_fil.py
+++ /dev/null
@@ -1,45 +0,0 @@
-from test_support import TESTFN
-from UserList import UserList
-
-# verify writelines with instance sequence
-l = UserList(['1', '2'])
-f = open(TESTFN, 'wb')
-f.writelines(l)
-f.close()
-f = open(TESTFN, 'rb')
-buf = f.read()
-f.close()
-assert buf == '12'
-
-# verify writelines with integers
-f = open(TESTFN, 'wb')
-try:
- f.writelines([1, 2, 3])
-except TypeError:
- pass
-else:
- print "writelines accepted sequence of integers"
-f.close()
-
-# verify writelines with integers in UserList
-f = open(TESTFN, 'wb')
-l = UserList([1,2,3])
-try:
- f.writelines(l)
-except TypeError:
- pass
-else:
- print "writelines accepted sequence of integers"
-f.close()
-
-# verify writelines with non-string object
-class NonString: pass
-
-f = open(TESTFN, 'wb')
-try:
- f.writelines([NonString(), NonString()])
-except TypeError:
- pass
-else:
- print "writelines accepted sequence of non-string objects"
-f.close()
diff --git a/Lib/dos-8x3/test_for.py b/Lib/dos-8x3/test_for.py
deleted file mode 100644
index 4fd2662..0000000
--- a/Lib/dos-8x3/test_for.py
+++ /dev/null
@@ -1,78 +0,0 @@
-"""This test checks for correct fork() behavior.
-
-We want fork1() semantics -- only the forking thread survives in the
-child after a fork().
-
-On some systems (e.g. Solaris without posix threads) we find that all
-active threads survive in the child after a fork(); this is an error.
-
-On BeOS, you CANNOT mix threads and fork(), the behaviour is undefined.
-That's OK, fork() is a grotesque hack anyway. ;-) [cjh]
-
-"""
-
-import os, sys, time, thread
-from test_support import TestSkipped
-
-try:
- if os.uname()[0] == "BeOS":
- raise TestSkipped, "can't mix os.fork with threads on BeOS"
-except AttributeError:
- pass
-
-try:
- os.fork
-except AttributeError:
- raise TestSkipped, "os.fork not defined -- skipping test_fork1"
-
-LONGSLEEP = 2
-
-SHORTSLEEP = 0.5
-
-NUM_THREADS = 4
-
-alive = {}
-
-stop = 0
-
-def f(id):
- while not stop:
- alive[id] = os.getpid()
- try:
- time.sleep(SHORTSLEEP)
- except IOError:
- pass
-
-def main():
- for i in range(NUM_THREADS):
- thread.start_new(f, (i,))
-
- time.sleep(LONGSLEEP)
-
- a = alive.keys()
- a.sort()
- assert a == range(NUM_THREADS)
-
- prefork_lives = alive.copy()
-
- cpid = os.fork()
-
- if cpid == 0:
- # Child
- time.sleep(LONGSLEEP)
- n = 0
- for key in alive.keys():
- if alive[key] != prefork_lives[key]:
- n = n+1
- os._exit(n)
- else:
- # Parent
- spid, status = os.waitpid(cpid, 0)
- assert spid == cpid
- assert status == 0, "cause = %d, exit = %d" % (status&0xff, status>>8)
- global stop
- # Tell threads to die
- stop = 1
- time.sleep(2*SHORTSLEEP) # Wait for threads to die
-
-main()
diff --git a/Lib/dos-8x3/test_gdb.py b/Lib/dos-8x3/test_gdb.py
deleted file mode 100644
index 030218e..0000000
--- a/Lib/dos-8x3/test_gdb.py
+++ /dev/null
@@ -1,40 +0,0 @@
-#! /usr/bin/env python
-"""Test script for the gdbm module
- Roger E. Masse
-"""
-
-import gdbm
-from gdbm import error
-from test_support import verbose, TestFailed
-
-filename= '/tmp/delete_me'
-
-g = gdbm.open(filename, 'c')
-g['a'] = 'b'
-g['12345678910'] = '019237410982340912840198242'
-a = g.keys()
-if verbose:
- print 'Test gdbm file keys: ', a
-
-g.has_key('a')
-g.close()
-try:
- g['a']
-except error:
- pass
-else:
- raise TestFailed, "expected gdbm.error accessing closed database"
-g = gdbm.open(filename, 'r')
-g.close()
-g = gdbm.open(filename, 'rw')
-g.close()
-g = gdbm.open(filename, 'w')
-g.close()
-g = gdbm.open(filename, 'n')
-g.close()
-
-try:
- import os
- os.unlink(filename)
-except:
- pass
diff --git a/Lib/dos-8x3/test_get.py b/Lib/dos-8x3/test_get.py
deleted file mode 100644
index 3927c1c..0000000
--- a/Lib/dos-8x3/test_get.py
+++ /dev/null
@@ -1,101 +0,0 @@
-# test_getopt.py
-# David Goodger <dgoodger@bigfoot.com> 2000-08-19
-
-import getopt
-from getopt import GetoptError
-from test_support import verbose
-
-def expectException(teststr, expected, failure=AssertionError):
- """Executes a statement passed in teststr, and raises an exception
- (failure) if the expected exception is *not* raised."""
- try:
- exec teststr
- except expected:
- pass
- else:
- raise failure
-
-if verbose:
- print 'Running tests on getopt.short_has_arg'
-assert getopt.short_has_arg('a', 'a:')
-assert not getopt.short_has_arg('a', 'a')
-expectException("tmp = getopt.short_has_arg('a', 'b')", GetoptError)
-expectException("tmp = getopt.short_has_arg('a', '')", GetoptError)
-
-if verbose:
- print 'Running tests on getopt.long_has_args'
-has_arg, option = getopt.long_has_args('abc', ['abc='])
-assert has_arg
-assert option == 'abc'
-has_arg, option = getopt.long_has_args('abc', ['abc'])
-assert not has_arg
-assert option == 'abc'
-has_arg, option = getopt.long_has_args('abc', ['abcd'])
-assert not has_arg
-assert option == 'abcd'
-expectException("has_arg, option = getopt.long_has_args('abc', ['def'])",
- GetoptError)
-expectException("has_arg, option = getopt.long_has_args('abc', [])",
- GetoptError)
-expectException("has_arg, option = " + \
- "getopt.long_has_args('abc', ['abcd','abcde'])",
- GetoptError)
-
-if verbose:
- print 'Running tests on getopt.do_shorts'
-opts, args = getopt.do_shorts([], 'a', 'a', [])
-assert opts == [('-a', '')]
-assert args == []
-opts, args = getopt.do_shorts([], 'a1', 'a:', [])
-assert opts == [('-a', '1')]
-assert args == []
-#opts, args = getopt.do_shorts([], 'a=1', 'a:', [])
-#assert opts == [('-a', '1')]
-#assert args == []
-opts, args = getopt.do_shorts([], 'a', 'a:', ['1'])
-assert opts == [('-a', '1')]
-assert args == []
-opts, args = getopt.do_shorts([], 'a', 'a:', ['1', '2'])
-assert opts == [('-a', '1')]
-assert args == ['2']
-expectException("opts, args = getopt.do_shorts([], 'a1', 'a', [])",
- GetoptError)
-expectException("opts, args = getopt.do_shorts([], 'a', 'a:', [])",
- GetoptError)
-
-if verbose:
- print 'Running tests on getopt.do_longs'
-opts, args = getopt.do_longs([], 'abc', ['abc'], [])
-assert opts == [('--abc', '')]
-assert args == []
-opts, args = getopt.do_longs([], 'abc=1', ['abc='], [])
-assert opts == [('--abc', '1')]
-assert args == []
-opts, args = getopt.do_longs([], 'abc=1', ['abcd='], [])
-assert opts == [('--abcd', '1')]
-assert args == []
-expectException("opts, args = getopt.do_longs([], 'abc=1', ['abc'], [])",
- GetoptError)
-expectException("opts, args = getopt.do_longs([], 'abc', ['abc='], [])",
- GetoptError)
-
-# note: the empty string between '-a' and '--beta' is significant:
-# it simulates an empty string option argument ('-a ""') on the command line.
-cmdline = ['-a', '1', '-b', '--alpha=2', '--beta', '-a', '3', '-a', '',
- '--beta', 'arg1', 'arg2']
-
-if verbose:
- print 'Running tests on getopt.getopt'
-opts, args = getopt.getopt(cmdline, 'a:b', ['alpha=', 'beta'])
-assert opts == [('-a', '1'), ('-b', ''), ('--alpha', '2'), ('--beta', ''),
- ('-a', '3'), ('-a', ''), ('--beta', '')]
-# Note ambiguity of ('-b', '') and ('-a', '') above. This must be
-# accounted for in the code that calls getopt().
-assert args == ['arg1', 'arg2']
-
-expectException(
- "opts, args = getopt.getopt(cmdline, 'a:b', ['alpha', 'beta'])",
- GetoptError)
-
-if verbose:
- print "Module getopt: tests completed successfully."
diff --git a/Lib/dos-8x3/test_gra.py b/Lib/dos-8x3/test_gra.py
deleted file mode 100755
index 0ca5a46..0000000
--- a/Lib/dos-8x3/test_gra.py
+++ /dev/null
@@ -1,649 +0,0 @@
-# Python test set -- part 1, grammar.
-# This just tests whether the parser accepts them all.
-
-from test_support import *
-
-print '1. Parser'
-
-print '1.1 Tokens'
-
-print '1.1.1 Backslashes'
-
-# Backslash means line continuation:
-x = 1 \
-+ 1
-if x <> 2: raise TestFailed, 'backslash for line continuation'
-
-# Backslash does not means continuation in comments :\
-x = 0
-if x <> 0: raise TestFailed, 'backslash ending comment'
-
-print '1.1.2 Numeric literals'
-
-print '1.1.2.1 Plain integers'
-if 0xff <> 255: raise TestFailed, 'hex int'
-if 0377 <> 255: raise TestFailed, 'octal int'
-if 2147483647 != 017777777777: raise TestFailed, 'large positive int'
-try:
- from sys import maxint
-except ImportError:
- maxint = 2147483647
-if maxint == 2147483647:
- if -2147483647-1 != 020000000000: raise TestFailed, 'max negative int'
- # XXX -2147483648
- if 037777777777 != -1: raise TestFailed, 'oct -1'
- if 0xffffffff != -1: raise TestFailed, 'hex -1'
- for s in '2147483648', '040000000000', '0x100000000':
- try:
- x = eval(s)
- except OverflowError:
- continue
-## raise TestFailed, \
- print \
- 'No OverflowError on huge integer literal ' + `s`
-elif eval('maxint == 9223372036854775807'):
- if eval('-9223372036854775807-1 != 01000000000000000000000'):
- raise TestFailed, 'max negative int'
- if eval('01777777777777777777777') != -1: raise TestFailed, 'oct -1'
- if eval('0xffffffffffffffff') != -1: raise TestFailed, 'hex -1'
- for s in '9223372036854775808', '02000000000000000000000', \
- '0x10000000000000000':
- try:
- x = eval(s)
- except OverflowError:
- continue
- raise TestFailed, \
- 'No OverflowError on huge integer literal ' + `s`
-else:
- print 'Weird maxint value', maxint
-
-print '1.1.2.2 Long integers'
-x = 0L
-x = 0l
-x = 0xffffffffffffffffL
-x = 0xffffffffffffffffl
-x = 077777777777777777L
-x = 077777777777777777l
-x = 123456789012345678901234567890L
-x = 123456789012345678901234567890l
-
-print '1.1.2.3 Floating point'
-x = 3.14
-x = 314.
-x = 0.314
-# XXX x = 000.314
-x = .314
-x = 3e14
-x = 3E14
-x = 3e-14
-x = 3e+14
-x = 3.e14
-x = .3e14
-x = 3.1e4
-
-print '1.1.3 String literals'
-
-##def assert(s):
-## if not s: raise TestFailed, 'see traceback'
-
-x = ''; y = ""; assert(len(x) == 0 and x == y)
-x = '\''; y = "'"; assert(len(x) == 1 and x == y and ord(x) == 39)
-x = '"'; y = "\""; assert(len(x) == 1 and x == y and ord(x) == 34)
-x = "doesn't \"shrink\" does it"
-y = 'doesn\'t "shrink" does it'
-assert(len(x) == 24 and x == y)
-x = "does \"shrink\" doesn't it"
-y = 'does "shrink" doesn\'t it'
-assert(len(x) == 24 and x == y)
-x = """
-The "quick"
-brown fox
-jumps over
-the 'lazy' dog.
-"""
-y = '\nThe "quick"\nbrown fox\njumps over\nthe \'lazy\' dog.\n'
-assert(x == y)
-y = '''
-The "quick"
-brown fox
-jumps over
-the 'lazy' dog.
-'''; assert(x == y)
-y = "\n\
-The \"quick\"\n\
-brown fox\n\
-jumps over\n\
-the 'lazy' dog.\n\
-"; assert(x == y)
-y = '\n\
-The \"quick\"\n\
-brown fox\n\
-jumps over\n\
-the \'lazy\' dog.\n\
-'; assert(x == y)
-
-
-print '1.2 Grammar'
-
-print 'single_input' # NEWLINE | simple_stmt | compound_stmt NEWLINE
-# XXX can't test in a script -- this rule is only used when interactive
-
-print 'file_input' # (NEWLINE | stmt)* ENDMARKER
-# Being tested as this very moment this very module
-
-print 'expr_input' # testlist NEWLINE
-# XXX Hard to test -- used only in calls to input()
-
-print 'eval_input' # testlist ENDMARKER
-x = eval('1, 0 or 1')
-
-print 'funcdef'
-### 'def' NAME parameters ':' suite
-### parameters: '(' [varargslist] ')'
-### varargslist: (fpdef ['=' test] ',')* ('*' NAME [',' ('**'|'*' '*') NAME]
-### | ('**'|'*' '*') NAME)
-### | fpdef ['=' test] (',' fpdef ['=' test])* [',']
-### fpdef: NAME | '(' fplist ')'
-### fplist: fpdef (',' fpdef)* [',']
-### arglist: (argument ',')* (argument | *' test [',' '**' test] | '**' test)
-### argument: [test '='] test # Really [keyword '='] test
-def f1(): pass
-f1()
-f1(*())
-f1(*(), **{})
-def f2(one_argument): pass
-def f3(two, arguments): pass
-def f4(two, (compound, (argument, list))): pass
-def a1(one_arg,): pass
-def a2(two, args,): pass
-def v0(*rest): pass
-def v1(a, *rest): pass
-def v2(a, b, *rest): pass
-def v3(a, (b, c), *rest): pass
-def d01(a=1): pass
-d01()
-d01(1)
-d01(*(1,))
-d01(**{'a':2})
-def d11(a, b=1): pass
-d11(1)
-d11(1, 2)
-d11(1, **{'b':2})
-def d21(a, b, c=1): pass
-d21(1, 2)
-d21(1, 2, 3)
-d21(*(1, 2, 3))
-d21(1, *(2, 3))
-d21(1, 2, *(3,))
-d21(1, 2, **{'c':3})
-def d02(a=1, b=2): pass
-d02()
-d02(1)
-d02(1, 2)
-d02(*(1, 2))
-d02(1, *(2,))
-d02(1, **{'b':2})
-d02(**{'a': 1, 'b': 2})
-def d12(a, b=1, c=2): pass
-d12(1)
-d12(1, 2)
-d12(1, 2, 3)
-def d22(a, b, c=1, d=2): pass
-d22(1, 2)
-d22(1, 2, 3)
-d22(1, 2, 3, 4)
-def d01v(a=1, *rest): pass
-d01v()
-d01v(1)
-d01v(1, 2)
-d01v(*(1, 2, 3, 4))
-d01v(*(1,))
-d01v(**{'a':2})
-def d11v(a, b=1, *rest): pass
-d11v(1)
-d11v(1, 2)
-d11v(1, 2, 3)
-def d21v(a, b, c=1, *rest): pass
-d21v(1, 2)
-d21v(1, 2, 3)
-d21v(1, 2, 3, 4)
-d21v(*(1, 2, 3, 4))
-d21v(1, 2, **{'c': 3})
-def d02v(a=1, b=2, *rest): pass
-d02v()
-d02v(1)
-d02v(1, 2)
-d02v(1, 2, 3)
-d02v(1, *(2, 3, 4))
-d02v(**{'a': 1, 'b': 2})
-def d12v(a, b=1, c=2, *rest): pass
-d12v(1)
-d12v(1, 2)
-d12v(1, 2, 3)
-d12v(1, 2, 3, 4)
-d12v(*(1, 2, 3, 4))
-d12v(1, 2, *(3, 4, 5))
-d12v(1, *(2,), **{'c': 3})
-def d22v(a, b, c=1, d=2, *rest): pass
-d22v(1, 2)
-d22v(1, 2, 3)
-d22v(1, 2, 3, 4)
-d22v(1, 2, 3, 4, 5)
-d22v(*(1, 2, 3, 4))
-d22v(1, 2, *(3, 4, 5))
-d22v(1, *(2, 3), **{'d': 4})
-
-### stmt: simple_stmt | compound_stmt
-# Tested below
-
-### simple_stmt: small_stmt (';' small_stmt)* [';']
-print 'simple_stmt'
-x = 1; pass; del x
-
-### small_stmt: expr_stmt | print_stmt | pass_stmt | del_stmt | flow_stmt | import_stmt | global_stmt | access_stmt | exec_stmt
-# Tested below
-
-print 'expr_stmt' # (exprlist '=')* exprlist
-1
-1, 2, 3
-x = 1
-x = 1, 2, 3
-x = y = z = 1, 2, 3
-x, y, z = 1, 2, 3
-abc = a, b, c = x, y, z = xyz = 1, 2, (3, 4)
-# NB these variables are deleted below
-
-print 'print_stmt' # 'print' (test ',')* [test]
-print 1, 2, 3
-print 1, 2, 3,
-print
-print 0 or 1, 0 or 1,
-print 0 or 1
-
-print 'extended print_stmt' # 'print' '>>' test ','
-import sys
-print >> sys.stdout, 1, 2, 3
-print >> sys.stdout, 1, 2, 3,
-print >> sys.stdout
-print >> sys.stdout, 0 or 1, 0 or 1,
-print >> sys.stdout, 0 or 1
-
-# test printing to an instance
-class Gulp:
- def write(self, msg): pass
-
-gulp = Gulp()
-print >> gulp, 1, 2, 3
-print >> gulp, 1, 2, 3,
-print >> gulp
-print >> gulp, 0 or 1, 0 or 1,
-print >> gulp, 0 or 1
-
-# test print >> None
-def driver():
- oldstdout = sys.stdout
- sys.stdout = Gulp()
- try:
- tellme(Gulp())
- tellme()
- finally:
- sys.stdout = oldstdout
-
-# we should see this once
-def tellme(file=sys.stdout):
- print >> file, 'hello world'
-
-driver()
-
-# we should not see this at all
-def tellme(file=None):
- print >> file, 'goodbye universe'
-
-driver()
-
-# syntax errors
-def check_syntax(statement):
- try:
- compile(statement, '<string>', 'exec')
- except SyntaxError:
- pass
- else:
- print 'Missing SyntaxError: "%s"' % statement
-check_syntax('print ,')
-check_syntax('print >> x,')
-
-print 'del_stmt' # 'del' exprlist
-del abc
-del x, y, (z, xyz)
-
-print 'pass_stmt' # 'pass'
-pass
-
-print 'flow_stmt' # break_stmt | continue_stmt | return_stmt | raise_stmt
-# Tested below
-
-print 'break_stmt' # 'break'
-while 1: break
-
-print 'continue_stmt' # 'continue'
-i = 1
-while i: i = 0; continue
-
-print 'return_stmt' # 'return' [testlist]
-def g1(): return
-def g2(): return 1
-g1()
-x = g2()
-
-print 'raise_stmt' # 'raise' test [',' test]
-try: raise RuntimeError, 'just testing'
-except RuntimeError: pass
-try: raise KeyboardInterrupt
-except KeyboardInterrupt: pass
-
-print 'import_stmt' # 'import' NAME (',' NAME)* | 'from' NAME 'import' ('*' | NAME (',' NAME)*)
-import sys
-import time, sys
-from time import time
-from sys import *
-from sys import path, argv
-
-print 'global_stmt' # 'global' NAME (',' NAME)*
-def f():
- global a
- global a, b
- global one, two, three, four, five, six, seven, eight, nine, ten
-
-print 'exec_stmt' # 'exec' expr ['in' expr [',' expr]]
-def f():
- z = None
- del z
- exec 'z=1+1\n'
- if z <> 2: raise TestFailed, 'exec \'z=1+1\'\\n'
- del z
- exec 'z=1+1'
- if z <> 2: raise TestFailed, 'exec \'z=1+1\''
- z = None
- del z
- exec u'z=1+1\n'
- if z <> 2: raise TestFailed, 'exec u\'z=1+1\'\\n'
- del z
- exec u'z=1+1'
- if z <> 2: raise TestFailed, 'exec u\'z=1+1\''
-f()
-g = {}
-exec 'z = 1' in g
-if g.has_key('__builtins__'): del g['__builtins__']
-if g <> {'z': 1}: raise TestFailed, 'exec \'z = 1\' in g'
-g = {}
-l = {}
-exec 'global a; a = 1; b = 2' in g, l
-if g.has_key('__builtins__'): del g['__builtins__']
-if l.has_key('__builtins__'): del l['__builtins__']
-if (g, l) <> ({'a':1}, {'b':2}): raise TestFailed, 'exec ... in g, l'
-
-
-### compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | funcdef | classdef
-# Tested below
-
-print 'if_stmt' # 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
-if 1: pass
-if 1: pass
-else: pass
-if 0: pass
-elif 0: pass
-if 0: pass
-elif 0: pass
-elif 0: pass
-elif 0: pass
-else: pass
-
-print 'while_stmt' # 'while' test ':' suite ['else' ':' suite]
-while 0: pass
-while 0: pass
-else: pass
-
-print 'for_stmt' # 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite]
-for i in 1, 2, 3: pass
-for i, j, k in (): pass
-else: pass
-class Squares:
- def __init__(self, max):
- self.max = max
- self.sofar = []
- def __len__(self): return len(self.sofar)
- def __getitem__(self, i):
- if not 0 <= i < self.max: raise IndexError
- n = len(self.sofar)
- while n <= i:
- self.sofar.append(n*n)
- n = n+1
- return self.sofar[i]
-n = 0
-for x in Squares(10): n = n+x
-if n != 285: raise TestFailed, 'for over growing sequence'
-
-print 'try_stmt'
-### try_stmt: 'try' ':' suite (except_clause ':' suite)+ ['else' ':' suite]
-### | 'try' ':' suite 'finally' ':' suite
-### except_clause: 'except' [expr [',' expr]]
-try:
- 1/0
-except ZeroDivisionError:
- pass
-else:
- pass
-try: 1/0
-except EOFError: pass
-except TypeError, msg: pass
-except RuntimeError, msg: pass
-except: pass
-else: pass
-try: 1/0
-except (EOFError, TypeError, ZeroDivisionError): pass
-try: 1/0
-except (EOFError, TypeError, ZeroDivisionError), msg: pass
-try: pass
-finally: pass
-
-print 'suite' # simple_stmt | NEWLINE INDENT NEWLINE* (stmt NEWLINE*)+ DEDENT
-if 1: pass
-if 1:
- pass
-if 1:
- #
- #
- #
- pass
- pass
- #
- pass
- #
-
-print 'test'
-### and_test ('or' and_test)*
-### and_test: not_test ('and' not_test)*
-### not_test: 'not' not_test | comparison
-if not 1: pass
-if 1 and 1: pass
-if 1 or 1: pass
-if not not not 1: pass
-if not 1 and 1 and 1: pass
-if 1 and 1 or 1 and 1 and 1 or not 1 and 1: pass
-
-print 'comparison'
-### comparison: expr (comp_op expr)*
-### comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not'
-if 1: pass
-x = (1 == 1)
-if 1 == 1: pass
-if 1 != 1: pass
-if 1 <> 1: pass
-if 1 < 1: pass
-if 1 > 1: pass
-if 1 <= 1: pass
-if 1 >= 1: pass
-if 1 is 1: pass
-if 1 is not 1: pass
-if 1 in (): pass
-if 1 not in (): pass
-if 1 < 1 > 1 == 1 >= 1 <= 1 <> 1 != 1 in 1 not in 1 is 1 is not 1: pass
-
-print 'binary mask ops'
-x = 1 & 1
-x = 1 ^ 1
-x = 1 | 1
-
-print 'shift ops'
-x = 1 << 1
-x = 1 >> 1
-x = 1 << 1 >> 1
-
-print 'additive ops'
-x = 1
-x = 1 + 1
-x = 1 - 1 - 1
-x = 1 - 1 + 1 - 1 + 1
-
-print 'multiplicative ops'
-x = 1 * 1
-x = 1 / 1
-x = 1 % 1
-x = 1 / 1 * 1 % 1
-
-print 'unary ops'
-x = +1
-x = -1
-x = ~1
-x = ~1 ^ 1 & 1 | 1 & 1 ^ -1
-x = -1*1/1 + 1*1 - ---1*1
-
-print 'selectors'
-### trailer: '(' [testlist] ')' | '[' subscript ']' | '.' NAME
-### subscript: expr | [expr] ':' [expr]
-f1()
-f2(1)
-f2(1,)
-f3(1, 2)
-f3(1, 2,)
-f4(1, (2, (3, 4)))
-v0()
-v0(1)
-v0(1,)
-v0(1,2)
-v0(1,2,3,4,5,6,7,8,9,0)
-v1(1)
-v1(1,)
-v1(1,2)
-v1(1,2,3)
-v1(1,2,3,4,5,6,7,8,9,0)
-v2(1,2)
-v2(1,2,3)
-v2(1,2,3,4)
-v2(1,2,3,4,5,6,7,8,9,0)
-v3(1,(2,3))
-v3(1,(2,3),4)
-v3(1,(2,3),4,5,6,7,8,9,0)
-print
-import sys, time
-c = sys.path[0]
-x = time.time()
-x = sys.modules['time'].time()
-a = '01234'
-c = a[0]
-c = a[-1]
-s = a[0:5]
-s = a[:5]
-s = a[0:]
-s = a[:]
-s = a[-5:]
-s = a[:-1]
-s = a[-4:-3]
-
-print 'atoms'
-### atom: '(' [testlist] ')' | '[' [testlist] ']' | '{' [dictmaker] '}' | '`' testlist '`' | NAME | NUMBER | STRING
-### dictmaker: test ':' test (',' test ':' test)* [',']
-
-x = (1)
-x = (1 or 2 or 3)
-x = (1 or 2 or 3, 2, 3)
-
-x = []
-x = [1]
-x = [1 or 2 or 3]
-x = [1 or 2 or 3, 2, 3]
-x = []
-
-x = {}
-x = {'one': 1}
-x = {'one': 1,}
-x = {'one' or 'two': 1 or 2}
-x = {'one': 1, 'two': 2}
-x = {'one': 1, 'two': 2,}
-x = {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6}
-
-x = `x`
-x = `1 or 2 or 3`
-x = x
-x = 'x'
-x = 123
-
-### exprlist: expr (',' expr)* [',']
-### testlist: test (',' test)* [',']
-# These have been exercised enough above
-
-print 'classdef' # 'class' NAME ['(' testlist ')'] ':' suite
-class B: pass
-class C1(B): pass
-class C2(B): pass
-class D(C1, C2, B): pass
-class C:
- def meth1(self): pass
- def meth2(self, arg): pass
- def meth3(self, a1, a2): pass
-
-# list comprehension tests
-nums = [1, 2, 3, 4, 5]
-strs = ["Apple", "Banana", "Coconut"]
-spcs = [" Apple", " Banana ", "Coco nut "]
-
-print [s.strip() for s in spcs]
-print [3 * x for x in nums]
-print [x for x in nums if x > 2]
-print [(i, s) for i in nums for s in strs]
-print [(i, s) for i in nums for s in [f for f in strs if "n" in f]]
-try:
- eval("[i, s for i in nums for s in strs]")
- print "FAIL: should have raised a SyntaxError!"
-except SyntaxError:
- print "good: got a SyntaxError as expected"
-
-try:
- eval("[x if y]")
- print "FAIL: should have raised a SyntaxError!"
-except SyntaxError:
- print "good: got a SyntaxError as expected"
-
-suppliers = [
- (1, "Boeing"),
- (2, "Ford"),
- (3, "Macdonalds")
-]
-
-parts = [
- (10, "Airliner"),
- (20, "Engine"),
- (30, "Cheeseburger")
-]
-
-suppart = [
- (1, 10), (1, 20), (2, 20), (3, 30)
-]
-
-print [
- (sname, pname)
- for (sno, sname) in suppliers
- for (pno, pname) in parts
- for (sp_sno, sp_pno) in suppart
- if sno == sp_sno and pno == sp_pno
-]
diff --git a/Lib/dos-8x3/test_gzi.py b/Lib/dos-8x3/test_gzi.py
deleted file mode 100644
index 2366d02..0000000
--- a/Lib/dos-8x3/test_gzi.py
+++ /dev/null
@@ -1,54 +0,0 @@
-
-import sys, os
-import gzip, tempfile
-
-filename = tempfile.mktemp()
-
-data1 = """ int length=DEFAULTALLOC, err = Z_OK;
- PyObject *RetVal;
- int flushmode = Z_FINISH;
- unsigned long start_total_out;
-
-"""
-
-data2 = """/* zlibmodule.c -- gzip-compatible data compression */
-/* See http://www.cdrom.com/pub/infozip/zlib/ */
-/* See http://www.winimage.com/zLibDll for Windows */
-"""
-
-f = gzip.GzipFile(filename, 'wb') ; f.write(data1 * 50) ; f.close()
-
-f = gzip.GzipFile(filename, 'rb') ; d = f.read() ; f.close()
-assert d == data1*50
-
-# Append to the previous file
-f = gzip.GzipFile(filename, 'ab') ; f.write(data2 * 15) ; f.close()
-
-f = gzip.GzipFile(filename, 'rb') ; d = f.read() ; f.close()
-assert d == (data1*50) + (data2*15)
-
-# Try .readline() with varying line lengths
-
-f = gzip.GzipFile(filename, 'rb')
-line_length = 0
-while 1:
- L = f.readline( line_length )
- if L == "" and line_length != 0: break
- assert len(L) <= line_length
- line_length = (line_length + 1) % 50
-f.close()
-
-# Try .readlines()
-
-f = gzip.GzipFile(filename, 'rb')
-L = f.readlines()
-f.close()
-
-f = gzip.GzipFile(filename, 'rb')
-while 1:
- L = f.readlines(150)
- if L == []: break
-f.close()
-
-
-os.unlink( filename )
diff --git a/Lib/dos-8x3/test_has.py b/Lib/dos-8x3/test_has.py
deleted file mode 100644
index 51b4c33..0000000
--- a/Lib/dos-8x3/test_has.py
+++ /dev/null
@@ -1,26 +0,0 @@
-# test the invariant that
-# iff a==b then hash(a)==hash(b)
-#
-
-import test_support
-
-
-def same_hash(*objlist):
- # hash each object given an raise TestFailed if
- # the hash values are not all the same
- hashed = map(hash, objlist)
- for h in hashed[1:]:
- if h != hashed[0]:
- raise TestFailed, "hashed values differ: %s" % `objlist`
-
-
-
-same_hash(1, 1L, 1.0, 1.0+0.0j)
-same_hash(int(1), long(1), float(1), complex(1))
-
-same_hash(long(1.23e300), float(1.23e300))
-
-same_hash(float(0.5), complex(0.5, 0.0))
-
-
-
diff --git a/Lib/dos-8x3/test_ima.py b/Lib/dos-8x3/test_ima.py
deleted file mode 100644
index 6b144c6..0000000
--- a/Lib/dos-8x3/test_ima.py
+++ /dev/null
@@ -1,171 +0,0 @@
-#! /usr/bin/env python
-
-"""Test script for the imageop module. This has the side
- effect of partially testing the imgfile module as well.
- Roger E. Masse
-"""
-
-from test_support import verbose, unlink
-
-import imageop, uu
-
-def main(use_rgbimg=1):
-
- # Create binary test files
- uu.decode(get_qualified_path('testrgb.uue'), 'test.rgb')
-
- if use_rgbimg:
- image, width, height = getrgbimage('test.rgb')
- else:
- 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'
- newimage = imageop.crop (image, 4, width, height, 0, 0, 1, 1)
-
- # Return image scaled to size newwidth by newheight. No interpolation
- # is done, scaling is done by simple-minded pixel duplication or removal.
- # Therefore, computer-generated images or dithered images will
- # not look nice after scaling.
- if verbose:
- 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
- # each destination pixel as the average of two vertically-aligned source
- # 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'
- videoimage = imageop.tovideo (image, 4, width, height)
-
- # Convert an rgb image to an 8 bit rgb
- if verbose:
- print 'rgb2rgb8'
- greyimage = imageop.rgb2rgb8(image, width, height)
-
- # Convert an 8 bit rgb image to a 24 bit rgb image
- if verbose:
- print 'rgb82rgb'
- image = imageop.rgb82rgb(greyimage, width, height)
-
- # Convert an rgb image to an 8 bit greyscale image
- if verbose:
- print 'rgb2grey'
- greyimage = imageop.rgb2grey(image, width, height)
-
- # Convert an 8 bit greyscale image to a 24 bit rgb image
- if verbose:
- print 'grey2rgb'
- image = imageop.grey2rgb(greyimage, width, height)
-
- # Convert a 8-bit deep greyscale image to a 1-bit deep image by
- # thresholding all the pixels. The resulting image is tightly packed
- # and is probably only useful as an argument to mono2grey.
- if verbose:
- print 'grey2mono'
- monoimage = imageop.grey2mono (greyimage, width, height, 0)
-
- # monoimage, width, height = getimage('monotest.rgb')
- # Convert a 1-bit monochrome image to an 8 bit greyscale or color image.
- # All pixels that are zero-valued on input get value p0 on output and
- # all one-value input pixels get value p1 on output. To convert a
- # monochrome black-and-white image to greyscale pass the values 0 and
- # 255 respectively.
- if verbose:
- 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'
- monoimage = imageop.dither2mono (greyimage, width, height)
-
- # Convert an 8-bit greyscale image to a 4-bit greyscale image without
- # dithering.
- if verbose:
- 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'
- 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'
- grey2image = imageop.dither2grey2 (greyimage, width, height)
-
- # Convert a 4-bit greyscale image to an 8-bit greyscale image.
- if verbose:
- print 'grey42grey'
- greyimage = imageop.grey42grey (grey4image, width, height)
-
- # Convert a 2-bit greyscale image to an 8-bit greyscale image.
- if verbose:
- print 'grey22grey'
- image = imageop.grey22grey (grey2image, width, height)
-
- # Cleanup
- unlink('test.rgb')
-
-def getrgbimage(name):
- """return a tuple consisting of image (in 'imgfile' format but
- using rgbimg instead) width and height"""
-
- import rgbimg
-
- try:
- sizes = rgbimg.sizeofimage(name)
- except rgbimg.error:
- name = get_qualified_path(name)
- sizes = rgbimg.sizeofimage(name)
- if verbose:
- print 'rgbimg opening test image: %s, sizes: %s' % (name, str(sizes))
-
- image = rgbimg.longimagedata(name)
- return (image, sizes[0], sizes[1])
-
-def getimage(name):
- """return a tuple consisting of
- image (in 'imgfile' format) width and height
- """
-
- import imgfile
-
- try:
- sizes = imgfile.getsizes(name)
- except imgfile.error:
- name = get_qualified_path(name)
- sizes = imgfile.getsizes(name)
- if verbose:
- print 'imgfile opening test image: %s, sizes: %s' % (name, str(sizes))
-
- image = imgfile.read(name)
- return (image, sizes[0], sizes[1])
-
-def get_qualified_path(name):
- """ return a more qualified path to name"""
- import sys
- import os
- path = sys.path
- try:
- path = [os.path.dirname(__file__)] + path
- except NameError:
- pass
- for dir in path:
- 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.
-# So we prefer to use it.
-main(use_rgbimg=1)
diff --git a/Lib/dos-8x3/test_img.py b/Lib/dos-8x3/test_img.py
deleted file mode 100644
index b074320..0000000
--- a/Lib/dos-8x3/test_img.py
+++ /dev/null
@@ -1,117 +0,0 @@
-#! /usr/bin/env python
-
-"""Simple test script for imgfile.c
- Roger E. Masse
-"""
-
-from test_support import verbose, unlink, findfile
-
-import imgfile, uu, os
-
-
-def main():
-
- uu.decode(findfile('testrgb.uue'), 'test.rgb')
- uu.decode(findfile('greyrgb.uue'), 'greytest.rgb')
-
- # Test a 3 byte color image
- testimage('test.rgb')
-
- # Test a 1 byte greyscale image
- testimage('greytest.rgb')
-
- unlink('test.rgb')
- unlink('greytest.rgb')
-
-def testimage(name):
- """Run through the imgfile's battery of possible methods
- on the image passed in name.
- """
-
- import sys
- import os
- import string
-
- outputfile = '/tmp/deleteme'
-
- # 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)
- 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)
- if verbose:
- 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
- # is the first in the string. This format is suitable to pass
- # to gl.lrectwrite, for instance.
- image = imgfile.read(name)
-
- # This function writes the RGB or greyscale data in data to
- # image file file. x and y give the size of the image, z is
- # 1 for 1 byte greyscale images or 3 for RGB images (which
- # 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'
- imgfile.write (outputfile, image, sizes[0], sizes[1], sizes[2])
-
-
- if verbose:
- 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
- # or duplicating pixels, so the result will be less than perfect,
- # especially for computer-generated images. Alternatively,
- # you can specify a filter to use to smoothen the image after
- # scaling. The filter forms supported are 'impulse', 'box',
- # 'triangle', 'quadratic' and 'gaussian'. If a filter is
- # specified blur is an optional parameter specifying the
- # blurriness of the filter. It defaults to 1.0. readscaled
- # makes no attempt to keep the aspect ratio correct, so that
- # is the users' responsibility.
- if verbose:
- 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
- # scan lines of the image are read or written from bottom to
- # 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'
- imgfile.ttob (1)
-
- if verbose:
- 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'
- imgfile.ttob (0)
-
- if verbose: print 'Filtering with "quadratic"'
- simage = imgfile.readscaled (name, sizes[0]/2, sizes[1]/2, 'quadratic')
- if verbose: print 'Filtering with "gaussian"'
- simage = imgfile.readscaled (name, sizes[0]/2, sizes[1]/2, 'gaussian', 1.0)
-
- if verbose:
- print 'Writing output file'
- imgfile.write (outputfile, simage, sizes[0]/2, sizes[1]/2, sizes[2])
-
- os.unlink(outputfile)
-
-main()
diff --git a/Lib/dos-8x3/test_imp.py b/Lib/dos-8x3/test_imp.py
deleted file mode 100644
index c7ab753..0000000
--- a/Lib/dos-8x3/test_imp.py
+++ /dev/null
@@ -1,44 +0,0 @@
-from test_support import TESTFN
-
-import os
-import random
-
-source = TESTFN + ".py"
-pyc = TESTFN + ".pyc"
-pyo = TESTFN + ".pyo"
-
-f = open(source, "w")
-print >> f, "# This will test Python's ability to import a .py file"
-a = random.randrange(1000)
-b = random.randrange(1000)
-print >> f, "a =", a
-print >> f, "b =", b
-f.close()
-
-try:
- try:
- mod = __import__(TESTFN)
- except ImportError, err:
- raise ValueError, "import from .py failed: %s" % err
-
- if mod.a != a or mod.b != b:
- print a, "!=", mod.a
- print b, "!=", mod.b
- raise ValueError, "module loaded (%s) but contents invalid" % mod
-finally:
- os.unlink(source)
-
-try:
- try:
- reload(mod)
- except ImportError, err:
- raise ValueError, "import from .pyc/.pyo failed: %s" % err
-finally:
- try:
- os.unlink(pyc)
- except os.error:
- pass
- try:
- os.unlink(pyo)
- except os.error:
- pass
diff --git a/Lib/dos-8x3/test_lar.py b/Lib/dos-8x3/test_lar.py
deleted file mode 100644
index 5b65237..0000000
--- a/Lib/dos-8x3/test_lar.py
+++ /dev/null
@@ -1,129 +0,0 @@
-#!python
-
-#----------------------------------------------------------------------
-# test largefile support on system where this makes sense
-#
-#XXX how to only run this when support is there
-#XXX how to only optionally run this, it will take along time
-#----------------------------------------------------------------------
-
-import test_support
-import os, struct, stat, sys
-
-
-# only run if the current system support large files
-f = open(test_support.TESTFN, 'w')
-try:
- # 2**31 == 2147483648
- f.seek(2147483649L)
-except OverflowError:
- raise test_support.TestSkipped, "platform does not have largefile support"
-else:
- f.close()
-
-
-# create >2GB file (2GB = 2147483648 bytes)
-size = 2500000000L
-name = test_support.TESTFN
-
-
-# on Windows this test comsumes large resources:
-# it takes a long time to build the >2GB file and takes >2GB of disk space
-# therefore test_support.use_large_resources must be defined to run this test
-if sys.platform[:3] == 'win' and not test_support.use_large_resources:
- raise test_support.TestSkipped, \
- "test requires %s bytes and a long time to run" % str(size)
-
-
-
-def expect(got_this, expect_this):
- if test_support.verbose:
- print '%s =?= %s ...' % (`got_this`, `expect_this`),
- if got_this != expect_this:
- if test_support.verbose:
- print 'no'
- raise test_support.TestFailed, 'got %s, but expected %s' %\
- (str(got_this), str(expect_this))
- else:
- if test_support.verbose:
- print 'yes'
-
-
-# test that each file function works as expected for a large (i.e. >2GB, do
-# we have to check >4GB) files
-
-if test_support.verbose:
- print 'create large file via seek (may be sparse file) ...'
-f = open(name, 'w')
-f.seek(size)
-f.write('a')
-f.flush()
-expect(os.fstat(f.fileno())[stat.ST_SIZE], size+1)
-if test_support.verbose:
- print 'check file size with os.fstat'
-f.close()
-if test_support.verbose:
- print 'check file size with os.stat'
-expect(os.stat(name)[stat.ST_SIZE], size+1)
-
-if test_support.verbose:
- print 'play around with seek() and read() with the built largefile'
-f = open(name, 'r')
-expect(f.tell(), 0)
-expect(f.read(1), '\000')
-expect(f.tell(), 1)
-f.seek(0)
-expect(f.tell(), 0)
-f.seek(0, 0)
-expect(f.tell(), 0)
-f.seek(42)
-expect(f.tell(), 42)
-f.seek(42, 0)
-expect(f.tell(), 42)
-f.seek(42, 1)
-expect(f.tell(), 84)
-f.seek(0, 1)
-expect(f.tell(), 84)
-f.seek(0, 2) # seek from the end
-expect(f.tell(), size + 1 + 0)
-f.seek(-10, 2)
-expect(f.tell(), size + 1 - 10)
-f.seek(-size-1, 2)
-expect(f.tell(), 0)
-f.seek(size)
-expect(f.tell(), size)
-expect(f.read(1), 'a') # the 'a' that was written at the end of the file above
-f.close()
-
-if test_support.verbose:
- print 'play around with os.lseek() with the built largefile'
-f = open(name, 'r')
-expect(os.lseek(f.fileno(), 0, 0), 0)
-expect(os.lseek(f.fileno(), 42, 0), 42)
-expect(os.lseek(f.fileno(), 42, 1), 84)
-expect(os.lseek(f.fileno(), 0, 1), 84)
-expect(os.lseek(f.fileno(), 0, 2), size+1+0)
-expect(os.lseek(f.fileno(), -10, 2), size+1-10)
-expect(os.lseek(f.fileno(), -size-1, 2), 0)
-expect(os.lseek(f.fileno(), size, 0), size)
-expect(f.read(1), 'a') # the 'a' that was written at the end of the file above
-f.close()
-
-
-# XXX add tests for truncate if it exists
-# XXX has truncate ever worked on Windows? specifically on WinNT I get:
-# "IOError: [Errno 13] Permission denied"
-##try:
-## newsize = size - 10
-## f.seek(newsize)
-## f.truncate()
-## expect(f.tell(), newsize)
-## newsize = newsize - 1
-## f.seek(0)
-## f.truncate(newsize)
-## expect(f.tell(), newsize)
-##except AttributeError:
-## pass
-
-os.unlink(name)
-
diff --git a/Lib/dos-8x3/test_lin.py b/Lib/dos-8x3/test_lin.py
deleted file mode 100644
index 7924a24..0000000
--- a/Lib/dos-8x3/test_lin.py
+++ /dev/null
@@ -1,89 +0,0 @@
-from test_support import verbose, findfile, TestFailed, TestSkipped
-
-import errno
-import fcntl
-import linuxaudiodev
-import os
-import sys
-import select
-import sunaudio
-import time
-import audioop
-
-SND_FORMAT_MULAW_8 = 1
-
-def play_sound_file(path):
- fp = open(path, 'r')
- size, enc, rate, nchannels, extra = sunaudio.gethdr(fp)
- data = fp.read()
- fp.close()
-
- if enc != SND_FORMAT_MULAW_8:
- print "Expect .au file with 8-bit mu-law samples"
- return
-
- try:
- a = linuxaudiodev.open('w')
- except linuxaudiodev.error, msg:
- if msg[0] in (errno.EACCES, errno.ENODEV):
- raise TestSkipped, msg
- raise TestFailed, msg
-
- # convert the data to 16-bit signed
- data = audioop.ulaw2lin(data, 2)
-
- # set the data format
- if sys.byteorder == 'little':
- fmt = linuxaudiodev.AFMT_S16_LE
- else:
- fmt = linuxaudiodev.AFMT_S16_BE
-
- # at least check that these methods can be invoked
- a.bufsize()
- a.obufcount()
- a.obuffree()
- a.getptr()
- a.fileno()
-
- # set parameters based on .au file headers
- a.setparameters(rate, 16, nchannels, fmt)
- a.write(data)
- a.flush()
- a.close()
-
-def test_errors():
- a = linuxaudiodev.open("w")
- size = 8
- fmt = linuxaudiodev.AFMT_U8
- rate = 8000
- nchannels = 1
- try:
- a.setparameters(-1, size, nchannels, fmt)
- except ValueError, msg:
- print msg
- try:
- a.setparameters(rate, -2, nchannels, fmt)
- except ValueError, msg:
- print msg
- try:
- a.setparameters(rate, size, 3, fmt)
- except ValueError, msg:
- print msg
- try:
- a.setparameters(rate, size, nchannels, 177)
- except ValueError, msg:
- print msg
- try:
- a.setparameters(rate, size, nchannels, linuxaudiodev.AFMT_U16_LE)
- except ValueError, msg:
- print msg
- try:
- a.setparameters(rate, 16, nchannels, fmt)
- except ValueError, msg:
- print msg
-
-def test():
- play_sound_file(findfile('audiotest.au'))
- test_errors()
-
-test()
diff --git a/Lib/dos-8x3/test_lon.py b/Lib/dos-8x3/test_lon.py
deleted file mode 100644
index 6a1f117..0000000
--- a/Lib/dos-8x3/test_lon.py
+++ /dev/null
@@ -1,260 +0,0 @@
-from test_support import TestFailed, verbose
-from string import join
-from random import random, randint
-
-# SHIFT should match the value in longintrepr.h for best testing.
-SHIFT = 15
-BASE = 2 ** SHIFT
-MASK = BASE - 1
-
-# Max number of base BASE digits to use in test cases. Doubling
-# this will at least quadruple the runtime.
-MAXDIGITS = 10
-
-# build some special values
-special = map(long, [0, 1, 2, BASE, BASE >> 1])
-special.append(0x5555555555555555L)
-special.append(0xaaaaaaaaaaaaaaaaL)
-# some solid strings of one bits
-p2 = 4L # 0 and 1 already added
-for i in range(2*SHIFT):
- special.append(p2 - 1)
- p2 = p2 << 1
-del p2
-# add complements & negations
-special = special + map(lambda x: ~x, special) + \
- map(lambda x: -x, special)
-
-# ------------------------------------------------------------ utilities
-
-# Use check instead of assert so the test still does something
-# under -O.
-
-def check(ok, *args):
- if not ok:
- raise TestFailed, join(map(str, args), " ")
-
-# Get quasi-random long consisting of ndigits digits (in base BASE).
-# quasi == the most-significant digit will not be 0, and the number
-# is constructed to contain long strings of 0 and 1 bits. These are
-# more likely than random bits to provoke digit-boundary errors.
-# The sign of the number is also random.
-
-def getran(ndigits):
- assert ndigits > 0
- nbits_hi = ndigits * SHIFT
- nbits_lo = nbits_hi - SHIFT + 1
- answer = 0L
- nbits = 0
- r = int(random() * (SHIFT * 2)) | 1 # force 1 bits to start
- while nbits < nbits_lo:
- bits = (r >> 1) + 1
- bits = min(bits, nbits_hi - nbits)
- assert 1 <= bits <= SHIFT
- nbits = nbits + bits
- answer = answer << bits
- if r & 1:
- answer = answer | ((1 << bits) - 1)
- r = int(random() * (SHIFT * 2))
- assert nbits_lo <= nbits <= nbits_hi
- if random() < 0.5:
- answer = -answer
- return answer
-
-# Get random long consisting of ndigits random digits (relative to base
-# BASE). The sign bit is also random.
-
-def getran2(ndigits):
- answer = 0L
- for i in range(ndigits):
- answer = (answer << SHIFT) | randint(0, MASK)
- if random() < 0.5:
- answer = -answer
- return answer
-
-# --------------------------------------------------------------- divmod
-
-def test_division_2(x, y):
- q, r = divmod(x, y)
- q2, r2 = x/y, x%y
- pab, pba = x*y, y*x
- check(pab == pba, "multiplication does not commute for", x, y)
- check(q == q2, "divmod returns different quotient than / for", x, y)
- check(r == r2, "divmod returns different mod than % for", x, y)
- check(x == q*y + r, "x != q*y + r after divmod on", x, y)
- if y > 0:
- check(0 <= r < y, "bad mod from divmod on", x, y)
- else:
- check(y < r <= 0, "bad mod from divmod on", x, y)
-
-def test_division(maxdigits=MAXDIGITS):
- print "long / * % divmod"
- digits = range(1, maxdigits+1)
- for lenx in digits:
- x = getran(lenx)
- for leny in digits:
- y = getran(leny) or 1L
- test_division_2(x, y)
-
-# -------------------------------------------------------------- ~ & | ^
-
-def test_bitop_identities_1(x):
- check(x & 0 == 0, "x & 0 != 0 for", x)
- check(x | 0 == x, "x | 0 != x for", x)
- check(x ^ 0 == x, "x ^ 0 != x for", x)
- check(x & -1 == x, "x & -1 != x for", x)
- check(x | -1 == -1, "x | -1 != -1 for", x)
- check(x ^ -1 == ~x, "x ^ -1 != ~x for", x)
- check(x == ~~x, "x != ~~x for", x)
- check(x & x == x, "x & x != x for", x)
- check(x | x == x, "x | x != x for", x)
- check(x ^ x == 0, "x ^ x != 0 for", x)
- check(x & ~x == 0, "x & ~x != 0 for", x)
- check(x | ~x == -1, "x | ~x != -1 for", x)
- check(x ^ ~x == -1, "x ^ ~x != -1 for", x)
- check(-x == 1 + ~x == ~(x-1), "not -x == 1 + ~x == ~(x-1) for", x)
- for n in range(2*SHIFT):
- p2 = 2L ** n
- check(x << n >> n == x, "x << n >> n != x for", x, n)
- check(x / p2 == x >> n, "x / p2 != x >> n for x n p2", x, n, p2)
- check(x * p2 == x << n, "x * p2 != x << n for x n p2", x, n, p2)
- check(x & -p2 == x >> n << n == x & ~(p2 - 1),
- "not x & -p2 == x >> n << n == x & ~(p2 - 1) for x n p2",
- x, n, p2)
-
-def test_bitop_identities_2(x, y):
- check(x & y == y & x, "x & y != y & x for", x, y)
- check(x | y == y | x, "x | y != y | x for", x, y)
- check(x ^ y == y ^ x, "x ^ y != y ^ x for", x, y)
- check(x ^ y ^ x == y, "x ^ y ^ x != y for", x, y)
- check(x & y == ~(~x | ~y), "x & y != ~(~x | ~y) for", x, y)
- check(x | y == ~(~x & ~y), "x | y != ~(~x & ~y) for", x, y)
- check(x ^ y == (x | y) & ~(x & y),
- "x ^ y != (x | y) & ~(x & y) for", x, y)
- check(x ^ y == (x & ~y) | (~x & y),
- "x ^ y == (x & ~y) | (~x & y) for", x, y)
- check(x ^ y == (x | y) & (~x | ~y),
- "x ^ y == (x | y) & (~x | ~y) for", x, y)
-
-def test_bitop_identities_3(x, y, z):
- check((x & y) & z == x & (y & z),
- "(x & y) & z != x & (y & z) for", x, y, z)
- check((x | y) | z == x | (y | z),
- "(x | y) | z != x | (y | z) for", x, y, z)
- check((x ^ y) ^ z == x ^ (y ^ z),
- "(x ^ y) ^ z != x ^ (y ^ z) for", x, y, z)
- check(x & (y | z) == (x & y) | (x & z),
- "x & (y | z) != (x & y) | (x & z) for", x, y, z)
- check(x | (y & z) == (x | y) & (x | z),
- "x | (y & z) != (x | y) & (x | z) for", x, y, z)
-
-def test_bitop_identities(maxdigits=MAXDIGITS):
- print "long bit-operation identities"
- for x in special:
- test_bitop_identities_1(x)
- digits = range(1, maxdigits+1)
- for lenx in digits:
- x = getran(lenx)
- test_bitop_identities_1(x)
- for leny in digits:
- y = getran(leny)
- test_bitop_identities_2(x, y)
- test_bitop_identities_3(x, y, getran((lenx + leny)/2))
-
-# ------------------------------------------------- hex oct repr str atol
-
-def slow_format(x, base):
- if (x, base) == (0, 8):
- # this is an oddball!
- return "0L"
- digits = []
- sign = 0
- if x < 0:
- sign, x = 1, -x
- while x:
- x, r = divmod(x, base)
- digits.append(int(r))
- digits.reverse()
- digits = digits or [0]
- return '-'[:sign] + \
- {8: '0', 10: '', 16: '0x'}[base] + \
- join(map(lambda i: "0123456789ABCDEF"[i], digits), '') + \
- "L"
-
-def test_format_1(x):
- from string import atol
- for base, mapper in (8, oct), (10, repr), (16, hex):
- got = mapper(x)
- expected = slow_format(x, base)
- check(got == expected, mapper.__name__, "returned",
- got, "but expected", expected, "for", x)
- check(atol(got, 0) == x, 'atol("%s", 0) !=' % got, x)
- # str() has to be checked a little differently since there's no
- # trailing "L"
- got = str(x)
- expected = slow_format(x, 10)[:-1]
- check(got == expected, mapper.__name__, "returned",
- got, "but expected", expected, "for", x)
-
-def test_format(maxdigits=MAXDIGITS):
- print "long str/hex/oct/atol"
- for x in special:
- test_format_1(x)
- for i in range(10):
- for lenx in range(1, maxdigits+1):
- x = getran(lenx)
- test_format_1(x)
-
-# ----------------------------------------------------------------- misc
-
-def test_misc(maxdigits=MAXDIGITS):
- print "long miscellaneous operations"
- import sys
-
- # check the extremes in int<->long conversion
- hugepos = sys.maxint
- hugeneg = -hugepos - 1
- hugepos_aslong = long(hugepos)
- hugeneg_aslong = long(hugeneg)
- check(hugepos == hugepos_aslong, "long(sys.maxint) != sys.maxint")
- check(hugeneg == hugeneg_aslong,
- "long(-sys.maxint-1) != -sys.maxint-1")
-
- # long -> int should not fail for hugepos_aslong or hugeneg_aslong
- try:
- check(int(hugepos_aslong) == hugepos,
- "converting sys.maxint to long and back to int fails")
- except OverflowError:
- raise TestFailed, "int(long(sys.maxint)) overflowed!"
- try:
- check(int(hugeneg_aslong) == hugeneg,
- "converting -sys.maxint-1 to long and back to int fails")
- except OverflowError:
- raise TestFailed, "int(long(-sys.maxint-1)) overflowed!"
-
- # but long -> int should overflow for hugepos+1 and hugeneg-1
- x = hugepos_aslong + 1
- try:
- int(x)
- raise ValueError
- except OverflowError:
- pass
- except:
- raise TestFailed, "int(long(sys.maxint) + 1) didn't overflow"
-
- x = hugeneg_aslong - 1
- try:
- int(x)
- raise ValueError
- except OverflowError:
- pass
- except:
- raise TestFailed, "int(long(-sys.maxint-1) - 1) didn't overflow"
-
-# ---------------------------------------------------------------- do it
-
-test_division()
-test_bitop_identities()
-test_format()
-test_misc()
-
diff --git a/Lib/dos-8x3/test_mat.py b/Lib/dos-8x3/test_mat.py
deleted file mode 100644
index b7fde0a..0000000
--- a/Lib/dos-8x3/test_mat.py
+++ /dev/null
@@ -1,195 +0,0 @@
-# Python test set -- math module
-# XXXX Should not do tests around zero only
-
-from test_support import *
-
-seps='1e-05'
-eps = eval(seps)
-print 'math module, testing with eps', seps
-import math
-
-def testit(name, value, expected):
- if abs(value-expected) > eps:
- raise TestFailed, '%s returned %f, expected %f'%\
- (name, value, expected)
-
-print 'constants'
-testit('pi', math.pi, 3.1415926)
-testit('e', math.e, 2.7182818)
-
-print 'acos'
-testit('acos(-1)', math.acos(-1), math.pi)
-testit('acos(0)', math.acos(0), math.pi/2)
-testit('acos(1)', math.acos(1), 0)
-
-print 'asin'
-testit('asin(-1)', math.asin(-1), -math.pi/2)
-testit('asin(0)', math.asin(0), 0)
-testit('asin(1)', math.asin(1), math.pi/2)
-
-print 'atan'
-testit('atan(-1)', math.atan(-1), -math.pi/4)
-testit('atan(0)', math.atan(0), 0)
-testit('atan(1)', math.atan(1), math.pi/4)
-
-print 'atan2'
-testit('atan2(-1, 0)', math.atan2(-1, 0), -math.pi/2)
-testit('atan2(-1, 1)', math.atan2(-1, 1), -math.pi/4)
-testit('atan2(0, 1)', math.atan2(0, 1), 0)
-testit('atan2(1, 1)', math.atan2(1, 1), math.pi/4)
-testit('atan2(1, 0)', math.atan2(1, 0), math.pi/2)
-
-print 'ceil'
-testit('ceil(0.5)', math.ceil(0.5), 1)
-testit('ceil(1.0)', math.ceil(1.0), 1)
-testit('ceil(1.5)', math.ceil(1.5), 2)
-testit('ceil(-0.5)', math.ceil(-0.5), 0)
-testit('ceil(-1.0)', math.ceil(-1.0), -1)
-testit('ceil(-1.5)', math.ceil(-1.5), -1)
-
-print 'cos'
-testit('cos(-pi/2)', math.cos(-math.pi/2), 0)
-testit('cos(0)', math.cos(0), 1)
-testit('cos(pi/2)', math.cos(math.pi/2), 0)
-testit('cos(pi)', math.cos(math.pi), -1)
-
-print 'cosh'
-testit('cosh(0)', math.cosh(0), 1)
-testit('cosh(2)-2*cosh(1)**2', math.cosh(2)-2*math.cosh(1)**2, -1) # Thanks to Lambert
-
-print 'exp'
-testit('exp(-1)', math.exp(-1), 1/math.e)
-testit('exp(0)', math.exp(0), 1)
-testit('exp(1)', math.exp(1), math.e)
-
-print 'fabs'
-testit('fabs(-1)', math.fabs(-1), 1)
-testit('fabs(0)', math.fabs(0), 0)
-testit('fabs(1)', math.fabs(1), 1)
-
-print 'floor'
-testit('floor(0.5)', math.floor(0.5), 0)
-testit('floor(1.0)', math.floor(1.0), 1)
-testit('floor(1.5)', math.floor(1.5), 1)
-testit('floor(-0.5)', math.floor(-0.5), -1)
-testit('floor(-1.0)', math.floor(-1.0), -1)
-testit('floor(-1.5)', math.floor(-1.5), -2)
-
-print 'fmod'
-testit('fmod(10,1)', math.fmod(10,1), 0)
-testit('fmod(10,0.5)', math.fmod(10,0.5), 0)
-testit('fmod(10,1.5)', math.fmod(10,1.5), 1)
-testit('fmod(-10,1)', math.fmod(-10,1), 0)
-testit('fmod(-10,0.5)', math.fmod(-10,0.5), 0)
-testit('fmod(-10,1.5)', math.fmod(-10,1.5), -1)
-
-print 'frexp'
-def testfrexp(name, (mant, exp), (emant, eexp)):
- if abs(mant-emant) > eps or exp <> eexp:
- raise TestFailed, '%s returned %s, expected %s'%\
- (name, `mant, exp`, `emant,eexp`)
-
-testfrexp('frexp(-1)', math.frexp(-1), (-0.5, 1))
-testfrexp('frexp(0)', math.frexp(0), (0, 0))
-testfrexp('frexp(1)', math.frexp(1), (0.5, 1))
-testfrexp('frexp(2)', math.frexp(2), (0.5, 2))
-
-print 'hypot'
-testit('hypot(0,0)', math.hypot(0,0), 0)
-testit('hypot(3,4)', math.hypot(3,4), 5)
-
-print 'ldexp'
-testit('ldexp(0,1)', math.ldexp(0,1), 0)
-testit('ldexp(1,1)', math.ldexp(1,1), 2)
-testit('ldexp(1,-1)', math.ldexp(1,-1), 0.5)
-testit('ldexp(-1,1)', math.ldexp(-1,1), -2)
-
-print 'log'
-testit('log(1/e)', math.log(1/math.e), -1)
-testit('log(1)', math.log(1), 0)
-testit('log(e)', math.log(math.e), 1)
-
-print 'log10'
-testit('log10(0.1)', math.log10(0.1), -1)
-testit('log10(1)', math.log10(1), 0)
-testit('log10(10)', math.log10(10), 1)
-
-print 'modf'
-def testmodf(name, (v1, v2), (e1, e2)):
- if abs(v1-e1) > eps or abs(v2-e2):
- raise TestFailed, '%s returned %s, expected %s'%\
- (name, `v1,v2`, `e1,e2`)
-
-testmodf('modf(1.5)', math.modf(1.5), (0.5, 1.0))
-testmodf('modf(-1.5)', math.modf(-1.5), (-0.5, -1.0))
-
-print 'pow'
-testit('pow(0,1)', math.pow(0,1), 0)
-testit('pow(1,0)', math.pow(1,0), 1)
-testit('pow(2,1)', math.pow(2,1), 2)
-testit('pow(2,-1)', math.pow(2,-1), 0.5)
-
-print 'sin'
-testit('sin(0)', math.sin(0), 0)
-testit('sin(pi/2)', math.sin(math.pi/2), 1)
-testit('sin(-pi/2)', math.sin(-math.pi/2), -1)
-
-print 'sinh'
-testit('sinh(0)', math.sinh(0), 0)
-testit('sinh(1)**2-cosh(1)**2', math.sinh(1)**2-math.cosh(1)**2, -1)
-testit('sinh(1)+sinh(-1)', math.sinh(1)+math.sinh(-1), 0)
-
-print 'sqrt'
-testit('sqrt(0)', math.sqrt(0), 0)
-testit('sqrt(1)', math.sqrt(1), 1)
-testit('sqrt(4)', math.sqrt(4), 2)
-
-print 'tan'
-testit('tan(0)', math.tan(0), 0)
-testit('tan(pi/4)', math.tan(math.pi/4), 1)
-testit('tan(-pi/4)', math.tan(-math.pi/4), -1)
-
-print 'tanh'
-testit('tanh(0)', math.tanh(0), 0)
-testit('tanh(1)+tanh(-1)', math.tanh(1)+math.tanh(-1), 0)
-
-# RED_FLAG 16-Oct-2000 Tim
-# While 2.0 is more consistent about exceptions than previous releases, it
-# still fails this part of the test on some platforms. For now, we only
-# *run* test_exceptions() in verbose mode, so that this isn't normally
-# tested.
-
-def test_exceptions():
- print 'exceptions'
- try:
- x = math.exp(-1000000000)
- except:
- # mathmodule.c is failing to weed out underflows from libm, or
- # we've got an fp format with huge dynamic range
- raise TestFailed("underflowing exp() should not have raised "
- "an exception")
- if x != 0:
- raise TestFailed("underflowing exp() should have returned 0")
-
- # If this fails, probably using a strict IEEE-754 conforming libm, and x
- # is +Inf afterwards. But Python wants overflows detected by default.
- try:
- x = math.exp(1000000000)
- except OverflowError:
- pass
- else:
- raise TestFailed("overflowing exp() didn't trigger OverflowError")
-
- # If this fails, it could be a puzzle. One odd possibility is that
- # mathmodule.c's CHECK() macro is getting confused while comparing
- # Inf (HUGE_VAL) to a NaN, and artificially setting errno to ERANGE
- # as a result (and so raising OverflowError instead).
- try:
- x = math.sqrt(-1.0)
- except ValueError:
- pass
- else:
- raise TestFailed("sqrt(-1) didn't raise ValueError")
-
-if verbose:
- test_exceptions()
diff --git a/Lib/dos-8x3/test_mim.py b/Lib/dos-8x3/test_mim.py
deleted file mode 100644
index 8b74421..0000000
--- a/Lib/dos-8x3/test_mim.py
+++ /dev/null
@@ -1,170 +0,0 @@
-"""Test program for MimeWriter module.
-
-The test program was too big to comfortably fit in the MimeWriter
-class, so it's here in its own file.
-
-This should generate Barry's example, modulo some quotes and newlines.
-
-"""
-
-
-from MimeWriter import MimeWriter
-
-SELLER = '''\
-INTERFACE Seller-1;
-
-TYPE Seller = OBJECT
- DOCUMENTATION "A simple Seller interface to test ILU"
- METHODS
- price():INTEGER,
- END;
-'''
-
-BUYER = '''\
-class Buyer:
- def __setup__(self, maxprice):
- self._maxprice = maxprice
-
- def __main__(self, kos):
- """Entry point upon arrival at a new KOS."""
- broker = kos.broker()
- # B4 == Barry's Big Bass Business :-)
- seller = broker.lookup('Seller_1.Seller', 'B4')
- if seller:
- price = seller.price()
- print 'Seller wants $', price, '... '
- if price > self._maxprice:
- print 'too much!'
- else:
- print "I'll take it!"
- else:
- print 'no seller found here'
-''' # Don't ask why this comment is here
-
-STATE = '''\
-# instantiate a buyer instance and put it in a magic place for the KOS
-# to find.
-__kp__ = Buyer()
-__kp__.__setup__(500)
-'''
-
-SIMPLE_METADATA = [
- ("Interpreter", "python"),
- ("Interpreter-Version", "1.3"),
- ("Owner-Name", "Barry Warsaw"),
- ("Owner-Rendezvous", "bwarsaw@cnri.reston.va.us"),
- ("Home-KSS", "kss.cnri.reston.va.us"),
- ("Identifier", "hdl://cnri.kss/my_first_knowbot"),
- ("Launch-Date", "Mon Feb 12 16:39:03 EST 1996"),
- ]
-
-COMPLEX_METADATA = [
- ("Metadata-Type", "complex"),
- ("Metadata-Key", "connection"),
- ("Access", "read-only"),
- ("Connection-Description", "Barry's Big Bass Business"),
- ("Connection-Id", "B4"),
- ("Connection-Direction", "client"),
- ]
-
-EXTERNAL_METADATA = [
- ("Metadata-Type", "complex"),
- ("Metadata-Key", "generic-interface"),
- ("Access", "read-only"),
- ("Connection-Description", "Generic Interface for All Knowbots"),
- ("Connection-Id", "generic-kp"),
- ("Connection-Direction", "client"),
- ]
-
-
-def main():
- import sys
-
- # Toplevel headers
-
- toplevel = MimeWriter(sys.stdout)
- toplevel.addheader("From", "bwarsaw@cnri.reston.va.us")
- toplevel.addheader("Date", "Mon Feb 12 17:21:48 EST 1996")
- toplevel.addheader("To", "kss-submit@cnri.reston.va.us")
- toplevel.addheader("MIME-Version", "1.0")
-
- # Toplevel body parts
-
- f = toplevel.startmultipartbody("knowbot", "801spam999",
- [("version", "0.1")], prefix=0)
- f.write("This is a multi-part message in MIME format.\n")
-
- # First toplevel body part: metadata
-
- md = toplevel.nextpart()
- md.startmultipartbody("knowbot-metadata", "802spam999")
-
- # Metadata part 1
-
- md1 = md.nextpart()
- md1.addheader("KP-Metadata-Type", "simple")
- md1.addheader("KP-Access", "read-only")
- m = MimeWriter(md1.startbody("message/rfc822"))
- for key, value in SIMPLE_METADATA:
- m.addheader("KPMD-" + key, value)
- m.flushheaders()
- del md1
-
- # Metadata part 2
-
- md2 = md.nextpart()
- for key, value in COMPLEX_METADATA:
- md2.addheader("KP-" + key, value)
- f = md2.startbody("text/isl")
- f.write(SELLER)
- del md2
-
- # Metadata part 3
-
- md3 = md.nextpart()
- f = md3.startbody("message/external-body",
- [("access-type", "URL"),
- ("URL", "hdl://cnri.kss/generic-knowbot")])
- m = MimeWriter(f)
- for key, value in EXTERNAL_METADATA:
- md3.addheader("KP-" + key, value)
- md3.startbody("text/isl")
- # Phantom body doesn't need to be written
-
- md.lastpart()
-
- # Second toplevel body part: code
-
- code = toplevel.nextpart()
- code.startmultipartbody("knowbot-code", "803spam999")
-
- # Code: buyer program source
-
- buyer = code.nextpart()
- buyer.addheader("KP-Module-Name", "BuyerKP")
- f = buyer.startbody("text/plain")
- f.write(BUYER)
-
- code.lastpart()
-
- # Third toplevel body part: state
-
- state = toplevel.nextpart()
- state.addheader("KP-Main-Module", "main")
- state.startmultipartbody("knowbot-state", "804spam999")
-
- # State: a bunch of assignments
-
- st = state.nextpart()
- st.addheader("KP-Module-Name", "main")
- f = st.startbody("text/plain")
- f.write(STATE)
-
- state.lastpart()
-
- # End toplevel body parts
-
- toplevel.lastpart()
-
-
-main()
diff --git a/Lib/dos-8x3/test_min.py b/Lib/dos-8x3/test_min.py
deleted file mode 100644
index 7afdf5d..0000000
--- a/Lib/dos-8x3/test_min.py
+++ /dev/null
@@ -1,413 +0,0 @@
-# test for xml.dom.minidom
-
-from xml.dom.minidom import parse, Node, Document, parseString
-import xml.parsers.expat
-
-import os.path
-import sys
-import traceback
-from test_support import verbose
-
-if __name__ == "__main__":
- base = sys.argv[0]
-else:
- base = __file__
-tstfile = os.path.join(os.path.dirname(base), "test.xml")
-del base
-
-def confirm(test, testname = "Test"):
- if test:
- print "Passed " + testname
- else:
- print "Failed " + testname
- raise Exception
-
-Node._debug = 1
-
-def testParseFromFile():
- from StringIO import StringIO
- dom = parse(StringIO(open(tstfile).read()))
- dom.unlink()
- confirm(isinstance(dom,Document))
-
-def testGetElementsByTagName():
- dom = parse(tstfile)
- confirm(dom.getElementsByTagName("LI") == \
- dom.documentElement.getElementsByTagName("LI"))
- dom.unlink()
-
-def testInsertBefore():
- dom = parse(tstfile)
- docel = dom.documentElement
- #docel.insertBefore( dom.createProcessingInstruction("a", "b"),
- # docel.childNodes[1])
-
- #docel.insertBefore( dom.createProcessingInstruction("a", "b"),
- # docel.childNodes[0])
-
- #confirm( docel.childNodes[0].tet == "a")
- #confirm( docel.childNodes[2].tet == "a")
- dom.unlink()
-
-def testAppendChild():
- dom = parse(tstfile)
- dom.documentElement.appendChild(dom.createComment(u"Hello"))
- confirm(dom.documentElement.childNodes[-1].nodeName == "#comment")
- confirm(dom.documentElement.childNodes[-1].data == "Hello")
- dom.unlink()
-
-def testNonZero():
- dom = parse(tstfile)
- confirm(dom)# should not be zero
- dom.appendChild(dom.createComment("foo"))
- confirm(not dom.childNodes[-1].childNodes)
- dom.unlink()
-
-def testUnlink():
- dom = parse(tstfile)
- dom.unlink()
-
-def testElement():
- dom = Document()
- dom.appendChild(dom.createElement("abc"))
- confirm(dom.documentElement)
- dom.unlink()
-
-def testAAA():
- dom = parseString("<abc/>")
- el = dom.documentElement
- el.setAttribute("spam", "jam2")
- dom.unlink()
-
-def testAAB():
- dom = parseString("<abc/>")
- el = dom.documentElement
- el.setAttribute("spam", "jam")
- el.setAttribute("spam", "jam2")
- dom.unlink()
-
-def testAddAttr():
- dom = Document()
- child = dom.appendChild(dom.createElement("abc"))
-
- child.setAttribute("def", "ghi")
- confirm(child.getAttribute("def") == "ghi")
- confirm(child.attributes["def"].value == "ghi")
-
- child.setAttribute("jkl", "mno")
- confirm(child.getAttribute("jkl") == "mno")
- confirm(child.attributes["jkl"].value == "mno")
-
- confirm(len(child.attributes) == 2)
-
- child.setAttribute("def", "newval")
- confirm(child.getAttribute("def") == "newval")
- confirm(child.attributes["def"].value == "newval")
-
- confirm(len(child.attributes) == 2)
- dom.unlink()
-
-def testDeleteAttr():
- dom = Document()
- child = dom.appendChild(dom.createElement("abc"))
-
- confirm(len(child.attributes) == 0)
- child.setAttribute("def", "ghi")
- confirm(len(child.attributes) == 1)
- del child.attributes["def"]
- confirm(len(child.attributes) == 0)
- dom.unlink()
-
-def testRemoveAttr():
- dom = Document()
- child = dom.appendChild(dom.createElement("abc"))
-
- child.setAttribute("def", "ghi")
- confirm(len(child.attributes) == 1)
- child.removeAttribute("def")
- confirm(len(child.attributes) == 0)
-
- dom.unlink()
-
-def testRemoveAttrNS():
- dom = Document()
- child = dom.appendChild(
- dom.createElementNS("http://www.python.org", "python:abc"))
- child.setAttributeNS("http://www.w3.org", "xmlns:python",
- "http://www.python.org")
- child.setAttributeNS("http://www.python.org", "python:abcattr", "foo")
- confirm(len(child.attributes) == 2)
- child.removeAttributeNS("http://www.python.org", "abcattr")
- confirm(len(child.attributes) == 1)
-
- dom.unlink()
-
-def testRemoveAttributeNode():
- dom = Document()
- child = dom.appendChild(dom.createElement("foo"))
- child.setAttribute("spam", "jam")
- confirm(len(child.attributes) == 1)
- node = child.getAttributeNode("spam")
- child.removeAttributeNode(node)
- confirm(len(child.attributes) == 0)
-
- dom.unlink()
-
-def testChangeAttr():
- dom = parseString("<abc/>")
- el = dom.documentElement
- el.setAttribute("spam", "jam")
- confirm(len(el.attributes) == 1)
- el.setAttribute("spam", "bam")
- confirm(len(el.attributes) == 1)
- el.attributes["spam"] = "ham"
- confirm(len(el.attributes) == 1)
- el.setAttribute("spam2", "bam")
- confirm(len(el.attributes) == 2)
- el.attributes[ "spam2"] = "bam2"
- confirm(len(el.attributes) == 2)
- dom.unlink()
-
-def testGetAttrList():
- pass
-
-def testGetAttrValues(): pass
-
-def testGetAttrLength(): pass
-
-def testGetAttribute(): pass
-
-def testGetAttributeNS(): pass
-
-def testGetAttributeNode(): pass
-
-def testGetElementsByTagNameNS(): pass
-
-def testGetEmptyNodeListFromElementsByTagNameNS(): pass
-
-def testElementReprAndStr():
- dom = Document()
- el = dom.appendChild(dom.createElement("abc"))
- string1 = repr(el)
- string2 = str(el)
- confirm(string1 == string2)
- dom.unlink()
-
-# commented out until Fredrick's fix is checked in
-def _testElementReprAndStrUnicode():
- dom = Document()
- el = dom.appendChild(dom.createElement(u"abc"))
- string1 = repr(el)
- string2 = str(el)
- confirm(string1 == string2)
- dom.unlink()
-
-# commented out until Fredrick's fix is checked in
-def _testElementReprAndStrUnicodeNS():
- dom = Document()
- el = dom.appendChild(
- dom.createElementNS(u"http://www.slashdot.org", u"slash:abc"))
- string1 = repr(el)
- string2 = str(el)
- confirm(string1 == string2)
- confirm(string1.find("slash:abc") != -1)
- dom.unlink()
- confirm(len(Node.allnodes) == 0)
-
-def testAttributeRepr():
- dom = Document()
- el = dom.appendChild(dom.createElement(u"abc"))
- node = el.setAttribute("abc", "def")
- confirm(str(node) == repr(node))
- dom.unlink()
- confirm(len(Node.allnodes) == 0)
-
-def testTextNodeRepr(): pass
-
-def testWriteXML():
- str = '<a b="c"/>'
- dom = parseString(str)
- domstr = dom.toxml()
- dom.unlink()
- confirm(str == domstr)
- confirm(len(Node.allnodes) == 0)
-
-def testProcessingInstruction(): pass
-
-def testProcessingInstructionRepr(): pass
-
-def testTextRepr(): pass
-
-def testWriteText(): pass
-
-def testDocumentElement(): pass
-
-def testTooManyDocumentElements(): pass
-
-def testCreateElementNS(): pass
-
-def testCreatAttributeNS(): pass
-
-def testParse(): pass
-
-def testParseString(): pass
-
-def testComment(): pass
-
-def testAttrListItem(): pass
-
-def testAttrListItems(): pass
-
-def testAttrListItemNS(): pass
-
-def testAttrListKeys(): pass
-
-def testAttrListKeysNS(): pass
-
-def testAttrListValues(): pass
-
-def testAttrListLength(): pass
-
-def testAttrList__getitem__(): pass
-
-def testAttrList__setitem__(): pass
-
-def testSetAttrValueandNodeValue(): pass
-
-def testParseElement(): pass
-
-def testParseAttributes(): pass
-
-def testParseElementNamespaces(): pass
-
-def testParseAttributeNamespaces(): pass
-
-def testParseProcessingInstructions(): pass
-
-def testChildNodes(): pass
-
-def testFirstChild(): pass
-
-def testHasChildNodes(): pass
-
-def testCloneElementShallow(): pass
-
-def testCloneElementShallowCopiesAttributes(): pass
-
-def testCloneElementDeep(): pass
-
-def testCloneDocumentShallow(): pass
-
-def testCloneDocumentDeep(): pass
-
-def testCloneAttributeShallow(): pass
-
-def testCloneAttributeDeep(): pass
-
-def testClonePIShallow(): pass
-
-def testClonePIDeep(): pass
-
-def testSiblings():
- doc = parseString("<doc><?pi?>text?<elm/></doc>")
- root = doc.documentElement
- (pi, text, elm) = root.childNodes
-
- confirm(pi.nextSibling is text and
- pi.previousSibling is None and
- text.nextSibling is elm and
- text.previousSibling is pi and
- elm.nextSibling is None and
- elm.previousSibling is text, "testSiblings")
-
- doc.unlink()
-
-def testParents():
- doc = parseString("<doc><elm1><elm2/><elm2><elm3/></elm2></elm1></doc>")
- root = doc.documentElement
- elm1 = root.childNodes[0]
- (elm2a, elm2b) = elm1.childNodes
- elm3 = elm2b.childNodes[0]
-
- confirm(root.parentNode is doc and
- elm1.parentNode is root and
- elm2a.parentNode is elm1 and
- elm2b.parentNode is elm1 and
- elm3.parentNode is elm2b, "testParents")
-
- doc.unlink()
-
-def testSAX2DOM():
- from xml.dom import pulldom
-
- sax2dom = pulldom.SAX2DOM()
- sax2dom.startDocument()
- sax2dom.startElement("doc", {})
- sax2dom.characters("text")
- sax2dom.startElement("subelm", {})
- sax2dom.characters("text")
- sax2dom.endElement("subelm")
- sax2dom.characters("text")
- sax2dom.endElement("doc")
- sax2dom.endDocument()
-
- doc = sax2dom.document
- root = doc.documentElement
- (text1, elm1, text2) = root.childNodes
- text3 = elm1.childNodes[0]
-
- confirm(text1.previousSibling is None and
- text1.nextSibling is elm1 and
- elm1.previousSibling is text1 and
- elm1.nextSibling is text2 and
- text2.previousSibling is elm1 and
- text2.nextSibling is None and
- text3.previousSibling is None and
- text3.nextSibling is None, "testSAX2DOM - siblings")
-
- confirm(root.parentNode is doc and
- text1.parentNode is root and
- elm1.parentNode is root and
- text2.parentNode is root and
- text3.parentNode is elm1, "testSAX2DOM - parents")
-
- doc.unlink()
-
-# --- MAIN PROGRAM
-
-names = globals().keys()
-names.sort()
-
-works = 1
-
-for name in names:
- if name.startswith("test"):
- func = globals()[name]
- try:
- func()
- print "Test Succeeded", name
- confirm(len(Node.allnodes) == 0,
- "assertion: len(Node.allnodes) == 0")
- if len(Node.allnodes):
- print "Garbage left over:"
- if verbose:
- print Node.allnodes.items()[0:10]
- else:
- # Don't print specific nodes if repeatable results
- # are needed
- print len(Node.allnodes)
- Node.allnodes = {}
- except Exception, e:
- works = 0
- print "Test Failed: ", name
- traceback.print_exception(*sys.exc_info())
- print `e`
- Node.allnodes = {}
-
-if works:
- print "All tests succeeded"
-else:
- print "\n\n\n\n************ Check for failures!"
-
-Node.debug = None # Delete debug output collected in a StringIO object
-Node._debug = 0 # And reset debug mode
diff --git a/Lib/dos-8x3/test_mma.py b/Lib/dos-8x3/test_mma.py
deleted file mode 100644
index 449c674..0000000
--- a/Lib/dos-8x3/test_mma.py
+++ /dev/null
@@ -1,121 +0,0 @@
-
-import mmap
-import string, os, re, sys
-
-PAGESIZE = mmap.PAGESIZE
-
-def test_both():
- "Test mmap module on Unix systems and Windows"
-
- # Create an mmap'ed file
- f = open('foo', 'w+')
-
- # Write 2 pages worth of data to the file
- f.write('\0'* PAGESIZE)
- f.write('foo')
- f.write('\0'* (PAGESIZE-3) )
-
- m = mmap.mmap(f.fileno(), 2 * PAGESIZE)
- f.close()
-
- # Simple sanity checks
- print ' Position of foo:', string.find(m, 'foo') / float(PAGESIZE), 'pages'
- assert string.find(m, 'foo') == PAGESIZE
-
- print ' Length of file:', len(m) / float(PAGESIZE), 'pages'
- assert len(m) == 2*PAGESIZE
-
- print ' Contents of byte 0:', repr(m[0])
- assert m[0] == '\0'
- print ' Contents of first 3 bytes:', repr(m[0:3])
- assert m[0:3] == '\0\0\0'
-
- # Modify the file's content
- print "\n Modifying file's content..."
- m[0] = '3'
- m[PAGESIZE +3: PAGESIZE +3+3]='bar'
-
- # Check that the modification worked
- print ' Contents of byte 0:', repr(m[0])
- assert m[0] == '3'
- print ' Contents of first 3 bytes:', repr(m[0:3])
- assert m[0:3] == '3\0\0'
- print ' Contents of second page:', repr(m[PAGESIZE-1 : PAGESIZE + 7])
- assert m[PAGESIZE-1 : PAGESIZE + 7] == '\0foobar\0'
-
- m.flush()
-
- # Test doing a regular expression match in an mmap'ed file
- match=re.search('[A-Za-z]+', m)
- if match == None:
- print ' ERROR: regex match on mmap failed!'
- else:
- start, end = match.span(0)
- length = end - start
-
- print ' Regex match on mmap (page start, length of match):',
- print start / float(PAGESIZE), length
-
- assert start == PAGESIZE
- assert end == PAGESIZE + 6
-
- # test seeking around (try to overflow the seek implementation)
- m.seek(0,0)
- print ' Seek to zeroth byte'
- assert m.tell() == 0
- m.seek(42,1)
- print ' Seek to 42nd byte'
- assert m.tell() == 42
- m.seek(0,2)
- print ' Seek to last byte'
- assert m.tell() == len(m)
-
- print ' Try to seek to negative position...'
- try:
- m.seek(-1)
- except ValueError:
- pass
- else:
- assert 0, 'expected a ValueError but did not get it'
-
- print ' Try to seek beyond end of mmap...'
- try:
- m.seek(1,2)
- except ValueError:
- pass
- else:
- assert 0, 'expected a ValueError but did not get it'
-
- print ' Try to seek to negative position...'
- try:
- m.seek(-len(m)-1,2)
- except ValueError:
- pass
- else:
- assert 0, 'expected a ValueError but did not get it'
-
- # Try resizing map
- print ' Attempting resize()'
- try:
- m.resize( 512 )
- except SystemError:
- # resize() not supported
- # No messages are printed, since the output of this test suite
- # would then be different across platforms.
- pass
- else:
- # resize() is supported
- assert len(m) == 512, "len(m) is %d, but expecting 512" % (len(m),)
- # Check that we can no longer seek beyond the new size.
- try:
- m.seek(513,0)
- except ValueError:
- pass
- else:
- assert 0, 'Could seek beyond the new size'
-
- m.close()
- os.unlink("foo")
- print ' Test passed'
-
-test_both()
diff --git a/Lib/dos-8x3/test_ntp.py b/Lib/dos-8x3/test_ntp.py
deleted file mode 100644
index 11f2f44..0000000
--- a/Lib/dos-8x3/test_ntp.py
+++ /dev/null
@@ -1,51 +0,0 @@
-import ntpath
-import string
-import os
-
-errors = 0
-
-def tester(fn, wantResult):
- fn = string.replace(fn, "\\", "\\\\")
- gotResult = eval(fn)
- if wantResult != gotResult:
- print "error!"
- print "evaluated: " + str(fn)
- print "should be: " + str(wantResult)
- print " returned: " + str(gotResult)
- print ""
- global errors
- errors = errors + 1
-
-tester('ntpath.splitdrive("c:\\foo\\bar")', ('c:', '\\foo\\bar'))
-tester('ntpath.splitunc("\\\\conky\\mountpoint\\foo\\bar")', ('\\\\conky\\mountpoint', '\\foo\\bar'))
-tester('ntpath.splitdrive("c:/foo/bar")', ('c:', '/foo/bar'))
-tester('ntpath.splitunc("//conky/mountpoint/foo/bar")', ('//conky/mountpoint', '/foo/bar'))
-
-tester('ntpath.split("c:\\foo\\bar")', ('c:\\foo', 'bar'))
-tester('ntpath.split("\\\\conky\\mountpoint\\foo\\bar")', ('\\\\conky\\mountpoint\\foo', 'bar'))
-
-tester('ntpath.split("c:\\")', ('c:\\', ''))
-tester('ntpath.split("\\\\conky\\mountpoint\\")', ('\\\\conky\\mountpoint', ''))
-
-tester('ntpath.split("c:/")', ('c:/', ''))
-tester('ntpath.split("//conky/mountpoint/")', ('//conky/mountpoint', ''))
-
-tester('ntpath.isabs("c:\\")', 1)
-tester('ntpath.isabs("\\\\conky\\mountpoint\\")', 1)
-tester('ntpath.isabs("\\foo")', 1)
-tester('ntpath.isabs("\\foo\\bar")', 1)
-
-tester('ntpath.abspath("C:\\")', "C:\\")
-
-tester('ntpath.commonprefix(["/home/swenson/spam", "/home/swen/spam"])',
- "/home/swen")
-tester('ntpath.commonprefix(["\\home\\swen\\spam", "\\home\\swen\\eggs"])',
- "\\home\\swen\\")
-tester('ntpath.commonprefix(["/home/swen/spam", "/home/swen/spam"])',
- "/home/swen/spam")
-
-if errors:
- print str(errors) + " errors."
-else:
- print "No errors. Thank your lucky stars."
-
diff --git a/Lib/dos-8x3/test_opc.py b/Lib/dos-8x3/test_opc.py
deleted file mode 100755
index bdace26..0000000
--- a/Lib/dos-8x3/test_opc.py
+++ /dev/null
@@ -1,101 +0,0 @@
-# Python test set -- part 2, opcodes
-
-from test_support import *
-
-
-print '2. Opcodes'
-print 'XXX Not yet fully implemented'
-
-print '2.1 try inside for loop'
-n = 0
-for i in range(10):
- n = n+i
- try: 1/0
- except NameError: pass
- except ZeroDivisionError: pass
- except TypeError: pass
- try: pass
- except: pass
- try: pass
- finally: pass
- n = n+i
-if n <> 90:
- raise TestFailed, 'try inside for'
-
-
-print '2.2 raise class exceptions'
-
-class AClass: pass
-class BClass(AClass): pass
-class CClass: pass
-class DClass(AClass):
- def __init__(self, ignore):
- pass
-
-try: raise AClass()
-except: pass
-
-try: raise AClass()
-except AClass: pass
-
-try: raise BClass()
-except AClass: pass
-
-try: raise BClass()
-except CClass: raise TestFailed
-except: pass
-
-a = AClass()
-b = BClass()
-
-try: raise AClass, b
-except BClass, v:
- if v != b: raise TestFailed
-else: raise TestFailed
-
-try: raise b
-except AClass, v:
- if v != b: raise TestFailed
-
-# not enough arguments
-try: raise BClass, a
-except TypeError: pass
-
-try: raise DClass, a
-except DClass, v:
- if not isinstance(v, DClass):
- raise TestFailed
-
-print '2.3 comparing function objects'
-
-f = eval('lambda: None')
-g = eval('lambda: None')
-if f != g: raise TestFailed
-
-f = eval('lambda a: a')
-g = eval('lambda a: a')
-if f != g: raise TestFailed
-
-f = eval('lambda a=1: a')
-g = eval('lambda a=1: a')
-if f != g: raise TestFailed
-
-f = eval('lambda: 0')
-g = eval('lambda: 1')
-if f == g: raise TestFailed
-
-f = eval('lambda: None')
-g = eval('lambda a: None')
-if f == g: raise TestFailed
-
-f = eval('lambda a: None')
-g = eval('lambda b: None')
-if f == g: raise TestFailed
-
-f = eval('lambda a: None')
-g = eval('lambda a=None: None')
-if f == g: raise TestFailed
-
-f = eval('lambda a=0: None')
-g = eval('lambda a=1: None')
-if f == g: raise TestFailed
diff --git a/Lib/dos-8x3/test_ope.py b/Lib/dos-8x3/test_ope.py
deleted file mode 100755
index 723e57c..0000000
--- a/Lib/dos-8x3/test_ope.py
+++ /dev/null
@@ -1,22 +0,0 @@
-# Test to see if openpty works. (But don't worry if it isn't available.)
-
-import os
-from test_support import verbose, TestFailed, TestSkipped
-
-try:
- if verbose:
- print "Calling os.openpty()"
- master, slave = os.openpty()
- if verbose:
- print "(master, slave) = (%d, %d)"%(master, slave)
-except AttributeError:
- raise TestSkipped, "No openpty() available."
-
-if not os.isatty(master):
- raise TestFailed, "Master-end of pty is not a terminal."
-if not os.isatty(slave):
- raise TestFailed, "Slave-end of pty is not a terminal."
-
-os.write(slave, 'Ping!')
-print os.read(master, 1024)
-
diff --git a/Lib/dos-8x3/test_par.py b/Lib/dos-8x3/test_par.py
deleted file mode 100644
index bc41de4..0000000
--- a/Lib/dos-8x3/test_par.py
+++ /dev/null
@@ -1,178 +0,0 @@
-import os.path
-import parser
-import pprint
-import sys
-
-from parser import expr, suite, sequence2ast
-from test_support import verbose
-
-#
-# First, we test that we can generate trees from valid source fragments,
-# and that these valid trees are indeed allowed by the tree-loading side
-# of the parser module.
-#
-
-def roundtrip(f, s):
- st1 = f(s)
- t = st1.totuple()
- st2 = parser.sequence2ast(t)
-
-def roundtrip_fromfile(filename):
- roundtrip(suite, open(filename).read())
-
-def test_expr(s):
- print "expr:", s
- roundtrip(expr, s)
-
-def test_suite(s):
- print "suite:", s
- roundtrip(suite, s)
-
-
-print "Expressions:"
-
-test_expr("foo(1)")
-test_expr("[1, 2, 3]")
-test_expr("[x**3 for x in range(20)]")
-test_expr("[x**3 for x in range(20) if x % 3]")
-test_expr("foo(*args)")
-test_expr("foo(*args, **kw)")
-test_expr("foo(**kw)")
-test_expr("foo(key=value)")
-test_expr("foo(key=value, *args)")
-test_expr("foo(key=value, *args, **kw)")
-test_expr("foo(key=value, **kw)")
-test_expr("foo(a, b, c, *args)")
-test_expr("foo(a, b, c, *args, **kw)")
-test_expr("foo(a, b, c, **kw)")
-test_expr("foo + bar")
-
-print
-print "Statements:"
-test_suite("print")
-test_suite("print 1")
-test_suite("print 1,")
-test_suite("print >>fp")
-test_suite("print >>fp, 1")
-test_suite("print >>fp, 1,")
-
-# expr_stmt
-test_suite("a")
-test_suite("a = b")
-test_suite("a = b = c = d = e")
-test_suite("a += b")
-test_suite("a -= b")
-test_suite("a *= b")
-test_suite("a /= b")
-test_suite("a %= b")
-test_suite("a &= b")
-test_suite("a |= b")
-test_suite("a ^= b")
-test_suite("a <<= b")
-test_suite("a >>= b")
-test_suite("a **= b")
-
-#d = os.path.dirname(os.__file__)
-#roundtrip_fromfile(os.path.join(d, "os.py"))
-#roundtrip_fromfile(os.path.join(d, "test", "test_parser.py"))
-
-#
-# Second, we take *invalid* trees and make sure we get ParserError
-# rejections for them.
-#
-
-print
-print "Invalid parse trees:"
-
-def check_bad_tree(tree, label):
- print
- print label
- try:
- sequence2ast(tree)
- except parser.ParserError:
- print "caught expected exception for invalid tree"
- pass
- else:
- print "test failed: did not properly detect invalid tree:"
- pprint.pprint(tree)
-
-
-# not even remotely valid:
-check_bad_tree((1, 2, 3), "<junk>")
-
-# print >>fp,
-tree = \
-(257,
- (264,
- (265,
- (266,
- (268,
- (1, 'print'),
- (35, '>>'),
- (290,
- (291,
- (292,
- (293,
- (295,
- (296,
- (297,
- (298, (299, (300, (301, (302, (303, (1, 'fp')))))))))))))),
- (12, ','))),
- (4, ''))),
- (0, ''))
-
-check_bad_tree(tree, "print >>fp,")
-
-# a,,c
-tree = \
-(258,
- (311,
- (290,
- (291,
- (292,
- (293,
- (295,
- (296, (297, (298, (299, (300, (301, (302, (303, (1, 'a')))))))))))))),
- (12, ','),
- (12, ','),
- (290,
- (291,
- (292,
- (293,
- (295,
- (296, (297, (298, (299, (300, (301, (302, (303, (1, 'c'))))))))))))))),
- (4, ''),
- (0, ''))
-
-check_bad_tree(tree, "a,,c")
-
-# a $= b
-tree = \
-(257,
- (264,
- (265,
- (266,
- (267,
- (312,
- (291,
- (292,
- (293,
- (294,
- (296,
- (297,
- (298,
- (299, (300, (301, (302, (303, (304, (1, 'a'))))))))))))))),
- (268, (37, '$=')),
- (312,
- (291,
- (292,
- (293,
- (294,
- (296,
- (297,
- (298,
- (299, (300, (301, (302, (303, (304, (1, 'b'))))))))))))))))),
- (4, ''))),
- (0, ''))
-
-check_bad_tree(tree, "a $= b")
diff --git a/Lib/dos-8x3/test_pic.py b/Lib/dos-8x3/test_pic.py
deleted file mode 100644
index 3c81fdd..0000000
--- a/Lib/dos-8x3/test_pic.py
+++ /dev/null
@@ -1,143 +0,0 @@
-# Test the pickle module
-
-# break into multiple strings to please font-lock-mode
-DATA = """(lp0
-I0
-aL1L
-aF2.0
-ac__builtin__
-complex
-p1
-""" \
-"""(F3.0
-F0.0
-tp2
-Rp3
-a(S'abc'
-p4
-g4
-""" \
-"""(i__main__
-C
-p5
-""" \
-"""(dp6
-S'foo'
-p7
-I1
-sS'bar'
-p8
-I2
-sbg5
-tp9
-ag9
-aI5
-a.
-"""
-
-BINDATA = ']q\000(K\000L1L\012G@\000\000\000\000\000\000\000c__builtin__\012complex\012q\001(G@\010\000\000\000\000\000\000G\000\000\000\000\000\000\000\000tq\002Rq\003(U\003abcq\004h\004(c__main__\012C\012q\005oq\006}q\007(U\003fooq\010K\001U\003barq\011K\002ubh\006tq\012h\012K\005e.'
-
-class C:
- def __cmp__(self, other):
- return cmp(self.__dict__, other.__dict__)
-
-import __main__
-__main__.C = C
-
-def dotest(pickle):
- c = C()
- c.foo = 1
- c.bar = 2
- x = [0, 1L, 2.0, 3.0+0j]
- y = ('abc', 'abc', c, c)
- x.append(y)
- x.append(y)
- x.append(5)
- r = []
- r.append(r)
- print "dumps()"
- s = pickle.dumps(x)
- print "loads()"
- x2 = pickle.loads(s)
- if x2 == x: print "ok"
- else: print "bad"
- print "loads() DATA"
- x2 = pickle.loads(DATA)
- if x2 == x: print "ok"
- else: print "bad"
- print "dumps() binary"
- s = pickle.dumps(x, 1)
- print "loads() binary"
- x2 = pickle.loads(s)
- if x2 == x: print "ok"
- else: print "bad"
- print "loads() BINDATA"
- x2 = pickle.loads(BINDATA)
- if x2 == x: print "ok"
- else: print "bad"
- s = pickle.dumps(r)
- print "dumps() RECURSIVE"
- x2 = pickle.loads(s)
- if x2 == r: print "ok"
- else: print "bad"
- # don't create cyclic garbage
- del x2[0]
- del r[0]
-
- # Test protection against closed files
- import tempfile, os
- fn = tempfile.mktemp()
- f = open(fn, "w")
- f.close()
- try:
- pickle.dump(123, f)
- except ValueError:
- pass
- else:
- print "dump to closed file should raise ValueError"
- f = open(fn, "r")
- f.close()
- try:
- pickle.load(f)
- except ValueError:
- pass
- else:
- print "load from closed file should raise ValueError"
- os.remove(fn)
-
- # Test specific bad cases
- for i in range(10):
- try:
- x = pickle.loads('garyp')
- except KeyError, y:
- # pickle
- del y
- except pickle.BadPickleGet, y:
- # cPickle
- del y
- else:
- print "unexpected success!"
- break
-
- # Test insecure strings
- insecure = ["abc", "2 + 2", # not quoted
- "'abc' + 'def'", # not a single quoted string
- "'abc", # quote is not closed
- "'abc\"", # open quote and close quote don't match
- "'abc' ?", # junk after close quote
- # some tests of the quoting rules
- "'abc\"\''",
- "'\\\\a\'\'\'\\\'\\\\\''",
- ]
- for s in insecure:
- buf = "S" + s + "\012p0\012."
- try:
- x = pickle.loads(buf)
- except ValueError:
- pass
- else:
- print "accepted insecure string: %s" % repr(buf)
-
-
-import pickle
-dotest(pickle)
diff --git a/Lib/dos-8x3/test_pol.py b/Lib/dos-8x3/test_pol.py
deleted file mode 100644
index 82d8372..0000000
--- a/Lib/dos-8x3/test_pol.py
+++ /dev/null
@@ -1,172 +0,0 @@
-# Test case for the os.poll() function
-
-import sys, os, select, random
-from test_support import verbose, TestSkipped, TESTFN
-
-try:
- select.poll
-except AttributeError:
- raise TestSkipped, "select.poll not defined -- skipping test_poll"
-
-
-def find_ready_matching(ready, flag):
- match = []
- for fd, mode in ready:
- if mode & flag:
- match.append(fd)
- return match
-
-def test_poll1():
- """Basic functional test of poll object
-
- Create a bunch of pipe and test that poll works with them.
- """
- print 'Running poll test 1'
- p = select.poll()
-
- NUM_PIPES = 12
- MSG = " This is a test."
- MSG_LEN = len(MSG)
- readers = []
- writers = []
- r2w = {}
- w2r = {}
-
- for i in range(NUM_PIPES):
- rd, wr = os.pipe()
- p.register(rd, select.POLLIN)
- p.register(wr, select.POLLOUT)
- readers.append(rd)
- writers.append(wr)
- r2w[rd] = wr
- w2r[wr] = rd
-
- while writers:
- ready = p.poll()
- ready_writers = find_ready_matching(ready, select.POLLOUT)
- if not ready_writers:
- raise RuntimeError, "no pipes ready for writing"
- wr = random.choice(ready_writers)
- os.write(wr, MSG)
-
- ready = p.poll()
- ready_readers = find_ready_matching(ready, select.POLLIN)
- if not ready_readers:
- raise RuntimeError, "no pipes ready for reading"
- rd = random.choice(ready_readers)
- buf = os.read(rd, MSG_LEN)
- assert len(buf) == MSG_LEN
- print buf
- os.close(r2w[rd]) ; os.close( rd )
- p.unregister( r2w[rd] )
- p.unregister( rd )
- writers.remove(r2w[rd])
-
- poll_unit_tests()
- print 'Poll test 1 complete'
-
-def poll_unit_tests():
- # returns NVAL for invalid file descriptor
- FD = 42
- try:
- os.close(FD)
- except OSError:
- pass
- p = select.poll()
- p.register(FD)
- r = p.poll()
- assert r[0] == (FD, select.POLLNVAL)
-
- f = open(TESTFN, 'w')
- fd = f.fileno()
- p = select.poll()
- p.register(f)
- r = p.poll()
- assert r[0][0] == fd
- f.close()
- r = p.poll()
- assert r[0] == (fd, select.POLLNVAL)
- os.unlink(TESTFN)
-
- # type error for invalid arguments
- p = select.poll()
- try:
- p.register(p)
- except TypeError:
- pass
- else:
- print "Bogus register call did not raise TypeError"
- try:
- p.unregister(p)
- except TypeError:
- pass
- else:
- print "Bogus unregister call did not raise TypeError"
-
- # can't unregister non-existent object
- p = select.poll()
- try:
- p.unregister(3)
- except KeyError:
- pass
- else:
- print "Bogus unregister call did not raise KeyError"
-
- # Test error cases
- pollster = select.poll()
- class Nope:
- pass
-
- class Almost:
- def fileno(self):
- return 'fileno'
-
- try:
- pollster.register( Nope(), 0 )
- except TypeError: pass
- else: print 'expected TypeError exception, not raised'
-
- try:
- pollster.register( Almost(), 0 )
- except TypeError: pass
- else: print 'expected TypeError exception, not raised'
-
-
-# Another test case for poll(). This is copied from the test case for
-# select(), modified to use poll() instead.
-
-def test_poll2():
- print 'Running poll test 2'
- 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')
- pollster = select.poll()
- pollster.register( p, select.POLLIN )
- for tout in (0, 1000, 2000, 4000, 8000, 16000) + (-1,)*10:
- if verbose:
- print 'timeout =', tout
- fdlist = pollster.poll(tout)
- if (fdlist == []):
- continue
- fd, flags = fdlist[0]
- if flags & select.POLLHUP:
- line = p.readline()
- if line != "":
- print 'error: pipe seems to be closed, but still returns data'
- continue
-
- elif flags & select.POLLIN:
- line = p.readline()
- if verbose:
- print `line`
- if not line:
- if verbose:
- print 'EOF'
- break
- continue
- else:
- print 'Unexpected return value from select.poll:', fdlist
- p.close()
- print 'Poll test 2 complete'
-
-test_poll1()
-test_poll2()
diff --git a/Lib/dos-8x3/test_pop.py b/Lib/dos-8x3/test_pop.py
deleted file mode 100644
index 1215847..0000000
--- a/Lib/dos-8x3/test_pop.py
+++ /dev/null
@@ -1,65 +0,0 @@
-#! /usr/bin/env python
-"""Test script for popen2.py
- Christian Tismer
-"""
-
-import os
-
-# popen2 contains its own testing routine
-# which is especially useful to see if open files
-# like stdin can be read successfully by a forked
-# subprocess.
-
-def main():
- print "Test popen2 module:"
- try:
- from os import popen
- except ImportError:
- # if we don't have os.popen, check that
- # we have os.fork. if not, skip the test
- # (by raising an ImportError)
- from os import fork
- import popen2
- popen2._test()
-
-
-def _test():
- # same test as popen2._test(), but using the os.popen*() API
- print "Testing os module:"
- import popen2
- cmd = "cat"
- teststr = "ab cd\n"
- if os.name == "nt":
- cmd = "more"
- # "more" doesn't act the same way across Windows flavors,
- # sometimes adding an extra newline at the start or the
- # end. So we strip whitespace off both ends for comparison.
- expected = teststr.strip()
- print "testing popen2..."
- w, r = os.popen2(cmd)
- w.write(teststr)
- w.close()
- got = r.read()
- if got.strip() != expected:
- raise ValueError("wrote %s read %s" % (`teststr`, `got`))
- print "testing popen3..."
- try:
- w, r, e = os.popen3([cmd])
- except:
- w, r, e = os.popen3(cmd)
- w.write(teststr)
- w.close()
- got = r.read()
- if got.strip() != expected:
- raise ValueError("wrote %s read %s" % (`teststr`, `got`))
- got = e.read()
- if got:
- raise ValueError("unexected %s on stderr" % `got`)
- for inst in popen2._active[:]:
- inst.wait()
- if popen2._active:
- raise ValueError("_active not empty")
- print "All OK"
-
-main()
-_test()
diff --git a/Lib/dos-8x3/test_pos.py b/Lib/dos-8x3/test_pos.py
deleted file mode 100644
index 27bee61..0000000
--- a/Lib/dos-8x3/test_pos.py
+++ /dev/null
@@ -1,42 +0,0 @@
-import posixpath
-import string
-
-errors = 0
-
-def tester(fn, wantResult):
- gotResult = eval(fn)
- if wantResult != gotResult:
- print "error!"
- print "evaluated: " + str(fn)
- print "should be: " + str(wantResult)
- print " returned: " + str(gotResult)
- print ""
- global errors
- errors = errors + 1
-
-tester('posixpath.splitdrive("/foo/bar")', ('', '/foo/bar'))
-
-tester('posixpath.split("/foo/bar")', ('/foo', 'bar'))
-tester('posixpath.split("/")', ('/', ''))
-tester('posixpath.split("foo")', ('', 'foo'))
-
-tester('posixpath.splitext("foo.ext")', ('foo', '.ext'))
-tester('posixpath.splitext("/foo/foo.ext")', ('/foo/foo', '.ext'))
-
-tester('posixpath.isabs("/")', 1)
-tester('posixpath.isabs("/foo")', 1)
-tester('posixpath.isabs("/foo/bar")', 1)
-tester('posixpath.isabs("foo/bar")', 0)
-
-tester('posixpath.commonprefix(["/home/swenson/spam", "/home/swen/spam"])',
- "/home/swen")
-tester('posixpath.commonprefix(["/home/swen/spam", "/home/swen/eggs"])',
- "/home/swen/")
-tester('posixpath.commonprefix(["/home/swen/spam", "/home/swen/spam"])',
- "/home/swen/spam")
-
-if errors:
- print str(errors) + " errors."
-else:
- print "No errors. Thank your lucky stars."
-
diff --git a/Lib/dos-8x3/test_pye.py b/Lib/dos-8x3/test_pye.py
deleted file mode 100644
index a119987..0000000
--- a/Lib/dos-8x3/test_pye.py
+++ /dev/null
@@ -1,152 +0,0 @@
-# Very simple test - Parse a file and print what happens
-
-# XXX TypeErrors on calling handlers, or on bad return values from a
-# handler, are obscure and unhelpful.
-
-from xml.parsers import expat
-
-class Outputter:
- def StartElementHandler(self, name, attrs):
- print 'Start element:\n\t', repr(name), attrs
-
- def EndElementHandler(self, name):
- print 'End element:\n\t', repr(name)
-
- def CharacterDataHandler(self, data):
- data = data.strip()
- if data:
- print 'Character data:'
- print '\t', repr(data)
-
- def ProcessingInstructionHandler(self, target, data):
- print 'PI:\n\t', repr(target), repr(data)
-
- def StartNamespaceDeclHandler(self, prefix, uri):
- print 'NS decl:\n\t', repr(prefix), repr(uri)
-
- def EndNamespaceDeclHandler(self, prefix):
- print 'End of NS decl:\n\t', repr(prefix)
-
- def StartCdataSectionHandler(self):
- print 'Start of CDATA section'
-
- def EndCdataSectionHandler(self):
- print 'End of CDATA section'
-
- def CommentHandler(self, text):
- print 'Comment:\n\t', repr(text)
-
- def NotationDeclHandler(self, *args):
- name, base, sysid, pubid = args
- print 'Notation declared:', args
-
- def UnparsedEntityDeclHandler(self, *args):
- entityName, base, systemId, publicId, notationName = args
- print 'Unparsed entity decl:\n\t', args
-
- def NotStandaloneHandler(self, userData):
- print 'Not standalone'
- return 1
-
- def ExternalEntityRefHandler(self, *args):
- context, base, sysId, pubId = args
- print 'External entity ref:', args
- return 1
-
- def DefaultHandler(self, userData):
- pass
-
- def DefaultHandlerExpand(self, userData):
- pass
-
-
-def confirm(ok):
- if ok:
- print "OK."
- else:
- print "Not OK."
-
-out = Outputter()
-parser = expat.ParserCreate(namespace_separator='!')
-
-# Test getting/setting returns_unicode
-parser.returns_unicode = 0; confirm(parser.returns_unicode == 0)
-parser.returns_unicode = 1; confirm(parser.returns_unicode == 1)
-parser.returns_unicode = 2; confirm(parser.returns_unicode == 1)
-parser.returns_unicode = 0; confirm(parser.returns_unicode == 0)
-
-HANDLER_NAMES = [
- 'StartElementHandler', 'EndElementHandler',
- 'CharacterDataHandler', 'ProcessingInstructionHandler',
- 'UnparsedEntityDeclHandler', 'NotationDeclHandler',
- 'StartNamespaceDeclHandler', 'EndNamespaceDeclHandler',
- 'CommentHandler', 'StartCdataSectionHandler',
- 'EndCdataSectionHandler',
- 'DefaultHandler', 'DefaultHandlerExpand',
- #'NotStandaloneHandler',
- 'ExternalEntityRefHandler'
- ]
-for name in HANDLER_NAMES:
- setattr(parser, name, getattr(out, name))
-
-data = '''\
-<?xml version="1.0" encoding="iso-8859-1" standalone="no"?>
-<?xml-stylesheet href="stylesheet.css"?>
-<!-- comment data -->
-<!DOCTYPE quotations SYSTEM "quotations.dtd" [
-<!ELEMENT root ANY>
-<!NOTATION notation SYSTEM "notation.jpeg">
-<!ENTITY acirc "â">
-<!ENTITY external_entity SYSTEM "entity.file">
-<!ENTITY unparsed_entity SYSTEM "entity.file" NDATA notation>
-%unparsed_entity;
-]>
-
-<root attr1="value1" attr2="value2ὀ">
-<myns:subelement xmlns:myns="http://www.python.org/namespace">
- Contents of subelements
-</myns:subelement>
-<sub2><![CDATA[contents of CDATA section]]></sub2>
-&external_entity;
-</root>
-'''
-
-# Produce UTF-8 output
-parser.returns_unicode = 0
-try:
- parser.Parse(data, 1)
-except expat.error:
- print '** Error', parser.ErrorCode, expat.ErrorString(parser.ErrorCode)
- print '** Line', parser.ErrorLineNumber
- print '** Column', parser.ErrorColumnNumber
- print '** Byte', parser.ErrorByteIndex
-
-# Try the parse again, this time producing Unicode output
-parser = expat.ParserCreate(namespace_separator='!')
-parser.returns_unicode = 1
-
-for name in HANDLER_NAMES:
- setattr(parser, name, getattr(out, name))
-try:
- parser.Parse(data, 1)
-except expat.error:
- print '** Error', parser.ErrorCode, expat.ErrorString(parser.ErrorCode)
- print '** Line', parser.ErrorLineNumber
- print '** Column', parser.ErrorColumnNumber
- print '** Byte', parser.ErrorByteIndex
-
-# Try parsing a file
-parser = expat.ParserCreate(namespace_separator='!')
-parser.returns_unicode = 1
-
-for name in HANDLER_NAMES:
- setattr(parser, name, getattr(out, name))
-import StringIO
-file = StringIO.StringIO(data)
-try:
- parser.ParseFile(file)
-except expat.error:
- print '** Error', parser.ErrorCode, expat.ErrorString(parser.ErrorCode)
- print '** Line', parser.ErrorLineNumber
- print '** Column', parser.ErrorColumnNumber
- print '** Byte', parser.ErrorByteIndex
diff --git a/Lib/dos-8x3/test_reg.py b/Lib/dos-8x3/test_reg.py
deleted file mode 100644
index 6a7f01b..0000000
--- a/Lib/dos-8x3/test_reg.py
+++ /dev/null
@@ -1,110 +0,0 @@
-from test_support import verbose
-import regex
-from regex_syntax import *
-
-re = 'a+b+c+'
-print 'no match:', regex.match(re, 'hello aaaabcccc world')
-print 'successful search:', regex.search(re, 'hello aaaabcccc world')
-try:
- cre = regex.compile('\(' + re)
-except regex.error:
- print 'caught expected exception'
-else:
- print 'expected regex.error not raised'
-
-print 'failed awk syntax:', regex.search('(a+)|(b+)', 'cdb')
-prev = regex.set_syntax(RE_SYNTAX_AWK)
-print 'successful awk syntax:', regex.search('(a+)|(b+)', 'cdb')
-regex.set_syntax(prev)
-print 'failed awk syntax:', regex.search('(a+)|(b+)', 'cdb')
-
-re = '\(<one>[0-9]+\) *\(<two>[0-9]+\)'
-print 'matching with group names and compile()'
-cre = regex.compile(re)
-print cre.match('801 999')
-try:
- print cre.group('one')
-except regex.error:
- print 'caught expected exception'
-else:
- print 'expected regex.error not raised'
-
-print 'matching with group names and symcomp()'
-cre = regex.symcomp(re)
-print cre.match('801 999')
-print cre.group(0)
-print cre.group('one')
-print cre.group(1, 2)
-print cre.group('one', 'two')
-print 'realpat:', cre.realpat
-print 'groupindex:', cre.groupindex
-
-re = 'world'
-cre = regex.compile(re)
-print 'not case folded search:', cre.search('HELLO WORLD')
-cre = regex.compile(re, regex.casefold)
-print 'case folded search:', cre.search('HELLO WORLD')
-
-print '__members__:', cre.__members__
-print 'regs:', cre.regs
-print 'last:', cre.last
-print 'translate:', len(cre.translate)
-print 'givenpat:', cre.givenpat
-
-print 'match with pos:', cre.match('hello world', 7)
-print 'search with pos:', cre.search('hello world there world', 7)
-print 'bogus group:', cre.group(0, 1, 3)
-try:
- print 'no name:', cre.group('one')
-except regex.error:
- print 'caught expected exception'
-else:
- print 'expected regex.error not raised'
-
-from regex_tests import *
-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
- elif len(t)==3:
- pattern, s, outcome = t
- else:
- raise ValueError, ('Test tuples should have 3 or 5 fields',t)
-
- try:
- 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
- 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
diff --git a/Lib/dos-8x3/test_rfc.py b/Lib/dos-8x3/test_rfc.py
deleted file mode 100644
index 36e7a51..0000000
--- a/Lib/dos-8x3/test_rfc.py
+++ /dev/null
@@ -1,126 +0,0 @@
-from test_support import verbose
-import rfc822, sys
-try:
- from cStringIO import StringIO
-except ImportError:
- from StringIO import StringIO
-
-def test(msg, results):
- fp = StringIO()
- fp.write(msg)
- fp.seek(0)
- m = rfc822.Message(fp)
- i = 0
-
- for n, a in m.getaddrlist('to') + m.getaddrlist('cc'):
- if verbose:
- print 'name:', repr(n), 'addr:', repr(a)
- try:
- mn, ma = results[i][0], results[i][1]
- except IndexError:
- print 'extra parsed address:', repr(n), repr(a)
- continue
- i = i + 1
- if mn == n and ma == a:
- if verbose:
- print ' [matched]'
- else:
- if verbose:
- print ' [no match]'
- print 'not found:', repr(n), repr(a)
-
- out = m.getdate('date')
- if out:
- if verbose:
- print 'Date:', m.getheader('date')
- if out == (1999, 1, 13, 23, 57, 35, 0, 0, 0):
- if verbose:
- print ' [matched]'
- else:
- if verbose:
- print ' [no match]'
- print 'Date conversion failed:', out
-
-# Note: all test cases must have the same date (in various formats),
-# or no date!
-
-test('''Date: Wed, 13 Jan 1999 23:57:35 -0500
-From: Guido van Rossum <guido@CNRI.Reston.VA.US>
-To: "Guido van
- : Rossum" <guido@python.org>
-Subject: test2
-
-test2
-''', [('Guido van\n : Rossum', 'guido@python.org')])
-
-test('''From: Barry <bwarsaw@python.org
-To: guido@python.org (Guido: the Barbarian)
-Subject: nonsense
-Date: Wednesday, January 13 1999 23:57:35 -0500
-
-test''', [('Guido: the Barbarian', 'guido@python.org'),
- ])
-
-test('''From: Barry <bwarsaw@python.org
-To: guido@python.org (Guido: the Barbarian)
-Cc: "Guido: the Madman" <guido@python.org>
-Date: 13-Jan-1999 23:57:35 EST
-
-test''', [('Guido: the Barbarian', 'guido@python.org'),
- ('Guido: the Madman', 'guido@python.org')
- ])
-
-test('''To: "The monster with
- the very long name: Guido" <guido@python.org>
-Date: Wed, 13 Jan 1999 23:57:35 -0500
-
-test''', [('The monster with\n the very long name: Guido',
- 'guido@python.org')])
-
-test('''To: "Amit J. Patel" <amitp@Theory.Stanford.EDU>
-CC: Mike Fletcher <mfletch@vrtelecom.com>,
- "'string-sig@python.org'" <string-sig@python.org>
-Cc: fooz@bat.com, bart@toof.com
-Cc: goit@lip.com
-Date: Wed, 13 Jan 1999 23:57:35 -0500
-
-test''', [('Amit J. Patel', 'amitp@Theory.Stanford.EDU'),
- ('Mike Fletcher', 'mfletch@vrtelecom.com'),
- ("'string-sig@python.org'", 'string-sig@python.org'),
- ('', 'fooz@bat.com'),
- ('', 'bart@toof.com'),
- ('', 'goit@lip.com'),
- ])
-
-# This one is just twisted. I don't know what the proper result should be,
-# but it shouldn't be to infloop, which is what used to happen!
-test('''To: <[smtp:dd47@mail.xxx.edu]_at_hmhq@hdq-mdm1-imgout.companay.com>
-Date: Wed, 13 Jan 1999 23:57:35 -0500
-
-test''', [('', ''),
- ('', 'dd47@mail.xxx.edu'),
- ('', '_at_hmhq@hdq-mdm1-imgout.companay.com')
- ])
-
-# This exercises the old commas-in-a-full-name bug, which should be doing the
-# right thing in recent versions of the module.
-test('''To: "last, first" <userid@foo.net>
-
-test''', [('last, first', 'userid@foo.net'),
- ])
-
-test('''To: (Comment stuff) "Quoted name"@somewhere.com
-
-test''', [('Comment stuff', '"Quoted name"@somewhere.com'),
- ])
-
-test('''To: :
-Cc: goit@lip.com
-Date: Wed, 13 Jan 1999 23:57:35 -0500
-
-test''', [('', 'goit@lip.com')])
-
-
-test('''To: guido@[132.151.1.21]
-
-foo''', [('', 'guido@[132.151.1.21]')])
diff --git a/Lib/dos-8x3/test_rgb.py b/Lib/dos-8x3/test_rgb.py
deleted file mode 100755
index 1fa201d..0000000
--- a/Lib/dos-8x3/test_rgb.py
+++ /dev/null
@@ -1,63 +0,0 @@
-# Testing rgbimg module
-
-import rgbimg, os, uu
-
-from test_support import verbose, unlink, findfile
-
-class error(Exception):
- pass
-
-print 'RGBimg test suite:'
-
-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')
-
-table = [
- ('testrgb.uue', 'test.rgb'),
- ('testimg.uue', 'test.rawimg'),
- ('testimgr.uue', 'test.rawimg.rev'),
- ]
-for source, target in table:
- source = findfile(source)
- target = findfile(target)
- if verbose:
- print "uudecoding", source, "->", target, "..."
- uu.decode(source, target)
-
-if verbose:
- print "testing..."
-
-ttob = rgbimg.ttob(0)
-if ttob != 0:
- raise error, 'ttob should start out as zero'
-
-testimg('test.rgb', 'test.rawimg')
-
-ttob = rgbimg.ttob(1)
-if ttob != 0:
- raise error, 'ttob should be zero'
-
-testimg('test.rgb', 'test.rawimg.rev')
-
-ttob = rgbimg.ttob(0)
-if ttob != 1:
- raise error, 'ttob should be one'
-
-ttob = rgbimg.ttob(0)
-if ttob != 0:
- raise error, 'ttob should be zero'
-
-for source, target in table:
- unlink(findfile(target))
diff --git a/Lib/dos-8x3/test_rot.py b/Lib/dos-8x3/test_rot.py
deleted file mode 100644
index a5c02aa..0000000
--- a/Lib/dos-8x3/test_rot.py
+++ /dev/null
@@ -1,28 +0,0 @@
-import rotor
-
-r = rotor.newrotor("you'll never guess this")
-r = rotor.newrotor("you'll never guess this", 12)
-
-A = 'spam and eggs'
-B = 'cheese shop'
-
-a = r.encrypt(A)
-print `a`
-b = r.encryptmore(B)
-print `b`
-
-A1 = r.decrypt(a)
-print A1
-if A1 <> A:
- print 'decrypt failed'
-
-B1 = r.decryptmore(b)
-print B1
-if B1 <> B:
- print 'decryptmore failed'
-
-try:
- r.setkey()
-except TypeError:
- pass
-r.setkey('you guessed it!')
diff --git a/Lib/dos-8x3/test_sel.py b/Lib/dos-8x3/test_sel.py
deleted file mode 100755
index b198cf1..0000000
--- a/Lib/dos-8x3/test_sel.py
+++ /dev/null
@@ -1,63 +0,0 @@
-# Testing select module
-from test_support import verbose
-import select
-import os
-
-# test some known error conditions
-try:
- rfd, wfd, xfd = select.select(1, 2, 3)
-except TypeError:
- pass
-else:
- print 'expected TypeError exception not raised'
-
-class Nope:
- pass
-
-class Almost:
- def fileno(self):
- return 'fileno'
-
-try:
- rfd, wfd, xfd = select.select([Nope()], [], [])
-except TypeError:
- pass
-else:
- print 'expected TypeError exception not raised'
-
-try:
- rfd, wfd, xfd = select.select([Almost()], [], [])
-except TypeError:
- pass
-else:
- print 'expected TypeError exception not raised'
-
-
-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)
- 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 'Unexpected return values from select():', rfd, wfd, xfd
- p.close()
-
-test()
-
diff --git a/Lib/dos-8x3/test_sig.py b/Lib/dos-8x3/test_sig.py
deleted file mode 100755
index 02b5dc3..0000000
--- a/Lib/dos-8x3/test_sig.py
+++ /dev/null
@@ -1,66 +0,0 @@
-# Test the signal module
-from test_support import verbose, TestSkipped
-import signal
-import os
-import sys
-
-if sys.platform[:3] in ('win', 'os2'):
- raise TestSkipped, "Can't test signal on %s" % sys.platform[:3]
-
-if verbose:
- x = '-x'
-else:
- x = '+x'
-pid = os.getpid()
-
-# Shell script that will send us asynchronous signals
-script = """
- (
- set %(x)s
- sleep 2
- kill -5 %(pid)d
- sleep 2
- kill -2 %(pid)d
- sleep 2
- kill -3 %(pid)d
- ) &
-""" % vars()
-
-def handlerA(*args):
- if verbose:
- print "handlerA", args
-
-HandlerBCalled = "HandlerBCalled" # Exception
-
-def handlerB(*args):
- if verbose:
- print "handlerB", args
- raise HandlerBCalled, args
-
-signal.alarm(20) # Entire test lasts at most 20 sec.
-signal.signal(5, handlerA)
-signal.signal(2, handlerB)
-signal.signal(3, signal.SIG_IGN)
-signal.signal(signal.SIGALRM, signal.default_int_handler)
-
-os.system(script)
-
-print "starting pause() loop..."
-
-try:
- while 1:
- if verbose:
- print "call pause()..."
- try:
- signal.pause()
- if verbose:
- print "pause() returned"
- except HandlerBCalled:
- if verbose:
- print "HandlerBCalled exception caught"
- else:
- pass
-
-except KeyboardInterrupt:
- if verbose:
- print "KeyboardInterrupt (assume the alarm() went off)"
diff --git a/Lib/dos-8x3/test_soc.py b/Lib/dos-8x3/test_soc.py
deleted file mode 100644
index 92b9336..0000000
--- a/Lib/dos-8x3/test_soc.py
+++ /dev/null
@@ -1,146 +0,0 @@
-# Not tested:
-# socket.fromfd()
-# sktobj.getsockopt()
-# sktobj.recvfrom()
-# sktobj.sendto()
-# sktobj.setblocking()
-# sktobj.setsockopt()
-# sktobj.shutdown()
-
-
-from test_support import verbose, TestFailed
-import socket
-import os
-import time
-import string
-
-def missing_ok(str):
- try:
- getattr(socket, str)
- except AttributeError:
- pass
-
-try: raise socket.error
-except socket.error: print "socket.error"
-
-socket.AF_INET
-
-socket.SOCK_STREAM
-socket.SOCK_DGRAM
-socket.SOCK_RAW
-socket.SOCK_RDM
-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",
- ):
- missing_ok(optional)
-
-socktype = socket.SocketType
-hostname = socket.gethostname()
-ip = socket.gethostbyname(hostname)
-hname, aliases, ipaddrs = socket.gethostbyaddr(ip)
-all_host_names = [hname] + aliases
-
-if verbose:
- print hostname
- print ip
- print hname, aliases, ipaddrs
- print all_host_names
-
-for name in all_host_names:
- if string.find(name, '.'):
- break
-else:
- print 'FQDN not found'
-
-print socket.getservbyname('telnet', 'tcp')
-try:
- socket.getservbyname('telnet', 'udp')
-except socket.error:
- pass
-
-
-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(("127.0.0.1", 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(("127.0.0.1", 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
deleted file mode 100644
index ea237cd..0000000
--- a/Lib/dos-8x3/test_str.py
+++ /dev/null
@@ -1,37 +0,0 @@
-# Tests StringIO and cStringIO
-
-def do_test(module):
- s = ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"+'\n')*5
- f = module.StringIO(s)
- print f.read(10)
- print f.readline()
- print len(f.readlines(60))
-
- f = module.StringIO()
- f.write('abcdef')
- f.seek(3)
- f.write('uvwxyz')
- f.write('!')
- print `f.getvalue()`
- f.close()
- f = module.StringIO()
- f.write(s)
- f.seek(10)
- f.truncate()
- print `f.getvalue()`
- f.seek(0)
- f.truncate(5)
- print `f.getvalue()`
- f.close()
- try:
- f.write("frobnitz")
- except ValueError, e:
- print "Caught expected ValueError writing to closed StringIO:"
- print e
- else:
- print "Failed to catch ValueError writing to closed StringIO."
-
-# Don't bother testing cStringIO without
-import StringIO, cStringIO
-do_test(StringIO)
-do_test(cStringIO)
diff --git a/Lib/dos-8x3/test_sun.py b/Lib/dos-8x3/test_sun.py
deleted file mode 100644
index af18761..0000000
--- a/Lib/dos-8x3/test_sun.py
+++ /dev/null
@@ -1,20 +0,0 @@
-from test_support import verbose, findfile, TestFailed
-import sunaudiodev
-import os
-
-def play_sound_file(path):
- fp = open(path, 'r')
- data = fp.read()
- fp.close()
- try:
- a = sunaudiodev.open('w')
- except sunaudiodev.error, msg:
- raise TestFailed, msg
- else:
- a.write(data)
- a.close()
-
-def test():
- play_sound_file(findfile('audiotest.au'))
-
-test()
diff --git a/Lib/dos-8x3/test_sup.py b/Lib/dos-8x3/test_sup.py
deleted file mode 100755
index 99bacda..0000000
--- a/Lib/dos-8x3/test_sup.py
+++ /dev/null
@@ -1,73 +0,0 @@
-"""Supporting definitions for the Python regression test."""
-
-
-class Error(Exception):
- """Base class for regression test exceptions."""
-
-class TestFailed(Error):
- """Test failed."""
-
-class TestSkipped(Error):
- """Test skipped.
-
- This can be raised to indicate that a test was deliberatly
- skipped, but not because a feature wasn't available. For
- example, if some resource can't be used, such as the network
- appears to be unavailable, this should be raised instead of
- TestFailed.
-
- """
-
-
-verbose = 1 # Flag set to 0 by regrtest.py
-use_large_resources = 1 # Flag set to 0 by regrtest.py
-
-def unload(name):
- import sys
- try:
- del sys.modules[name]
- except KeyError:
- pass
-
-def forget(modname):
- unload(modname)
- import sys, os
- for dirname in sys.path:
- try:
- os.unlink(os.path.join(dirname, modname + '.pyc'))
- except os.error:
- pass
-
-FUZZ = 1e-6
-
-def fcmp(x, y): # fuzzy comparison function
- if type(x) == type(0.0) or type(y) == type(0.0):
- try:
- x, y = coerce(x, y)
- fuzz = (abs(x) + abs(y)) * FUZZ
- if abs(x-y) <= fuzz:
- return 0
- except:
- pass
- elif type(x) == type(y) and type(x) in (type(()), type([])):
- for i in range(min(len(x), len(y))):
- outcome = fcmp(x[i], y[i])
- if outcome <> 0:
- return outcome
- return cmp(len(x), len(y))
- return cmp(x, y)
-
-TESTFN = '@test' # Filename used for testing
-from os import unlink
-
-def findfile(file, here=__file__):
- import os
- if os.path.isabs(file):
- return file
- import sys
- path = sys.path
- path = [os.path.dirname(here)] + path
- for dn in path:
- fn = os.path.join(dn, file)
- if os.path.exists(fn): return fn
- return file
diff --git a/Lib/dos-8x3/test_thr.py b/Lib/dos-8x3/test_thr.py
deleted file mode 100755
index 710fb89..0000000
--- a/Lib/dos-8x3/test_thr.py
+++ /dev/null
@@ -1,113 +0,0 @@
-# Very rudimentary test of thread module
-
-# Create a bunch of threads, let each do some work, wait until all are done
-
-from test_support import verbose
-import random
-import thread
-import time
-
-mutex = thread.allocate_lock()
-rmutex = thread.allocate_lock() # for calls to random
-running = 0
-done = thread.allocate_lock()
-done.acquire()
-
-numtasks = 10
-
-def task(ident):
- global running
- rmutex.acquire()
- delay = random.random() * numtasks
- rmutex.release()
- if verbose:
- print 'task', ident, 'will run for', round(delay, 1), 'sec'
- time.sleep(delay)
- if verbose:
- print 'task', ident, 'done'
- mutex.acquire()
- running = running - 1
- if running == 0:
- done.release()
- mutex.release()
-
-next_ident = 0
-def newtask():
- global next_ident, running
- mutex.acquire()
- next_ident = next_ident + 1
- if verbose:
- print 'creating task', next_ident
- thread.start_new_thread(task, (next_ident,))
- running = running + 1
- mutex.release()
-
-for i in range(numtasks):
- newtask()
-
-print 'waiting for all tasks to complete'
-done.acquire()
-print 'all tasks done'
-
-class barrier:
- def __init__(self, n):
- self.n = n
- self.waiting = 0
- self.checkin = thread.allocate_lock()
- self.checkout = thread.allocate_lock()
- self.checkout.acquire()
-
- def enter(self):
- checkin, checkout = self.checkin, self.checkout
-
- checkin.acquire()
- self.waiting = self.waiting + 1
- if self.waiting == self.n:
- self.waiting = self.n - 1
- checkout.release()
- return
- checkin.release()
-
- checkout.acquire()
- self.waiting = self.waiting - 1
- if self.waiting == 0:
- checkin.release()
- return
- checkout.release()
-
-numtrips = 3
-def task2(ident):
- global running
- for i in range(numtrips):
- if ident == 0:
- # give it a good chance to enter the next
- # barrier before the others are all out
- # of the current one
- delay = 0.001
- else:
- rmutex.acquire()
- delay = random.random() * numtasks
- rmutex.release()
- if verbose:
- print 'task', ident, 'will run for', round(delay, 1), 'sec'
- time.sleep(delay)
- if verbose:
- print 'task', ident, 'entering barrier', i
- bar.enter()
- if verbose:
- print 'task', ident, 'leaving barrier', i
- mutex.acquire()
- running = running - 1
- if running == 0:
- done.release()
- mutex.release()
-
-print '\n*** Barrier Test ***'
-if done.acquire(0):
- raise ValueError, "'done' should have remained acquired"
-bar = barrier(numtasks)
-running = numtasks
-for i in range(numtasks):
- thread.start_new_thread(task2, (i,))
-done.acquire()
-print 'all tasks done'
diff --git a/Lib/dos-8x3/test_tim.py b/Lib/dos-8x3/test_tim.py
deleted file mode 100644
index 03d081e..0000000
--- a/Lib/dos-8x3/test_tim.py
+++ /dev/null
@@ -1,39 +0,0 @@
-import time
-
-time.altzone
-time.clock()
-t = time.time()
-time.asctime(time.gmtime(t))
-if time.ctime(t) <> time.asctime(time.localtime(t)):
- print 'time.ctime(t) <> time.asctime(time.localtime(t))'
-
-time.daylight
-if long(time.mktime(time.localtime(t))) <> long(t):
- print 'time.mktime(time.localtime(t)) <> 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', '%'):
- format = ' %' + directive
- try:
- time.strftime(format, tt)
- except ValueError:
- print 'conversion specifier:', format, ' failed.'
-
-time.timezone
-time.tzname
-
-# expected errors
-try:
- time.asctime(0)
-except TypeError:
- pass
-
-try:
- time.mktime((999999, 999999, 999999, 999999,
- 999999, 999999, 999999, 999999,
- 999999))
-except OverflowError:
- pass
diff --git a/Lib/dos-8x3/test_tok.py b/Lib/dos-8x3/test_tok.py
deleted file mode 100644
index cd97e9a..0000000
--- a/Lib/dos-8x3/test_tok.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from test_support import verbose, findfile
-import tokenize, os, sys
-
-if verbose:
- print 'starting...'
-file = open(findfile('tokenize_tests.py'))
-tokenize.tokenize(file.readline)
-if verbose:
- print 'finished'
-
diff --git a/Lib/dos-8x3/test_typ.py b/Lib/dos-8x3/test_typ.py
deleted file mode 100755
index e3a51f0..0000000
--- a/Lib/dos-8x3/test_typ.py
+++ /dev/null
@@ -1,267 +0,0 @@
-# Python test set -- part 6, built-in types
-
-from test_support import *
-
-print '6. Built-in types'
-
-print '6.1 Truth value testing'
-if None: raise TestFailed, 'None is true instead of false'
-if 0: raise TestFailed, '0 is true instead of false'
-if 0L: raise TestFailed, '0L is true instead of false'
-if 0.0: raise TestFailed, '0.0 is true instead of false'
-if '': raise TestFailed, '\'\' is true instead of false'
-if (): raise TestFailed, '() is true instead of false'
-if []: raise TestFailed, '[] is true instead of false'
-if {}: raise TestFailed, '{} is true instead of false'
-if not 1: raise TestFailed, '1 is false instead of true'
-if not 1L: raise TestFailed, '1L is false instead of true'
-if not 1.0: raise TestFailed, '1.0 is false instead of true'
-if not 'x': raise TestFailed, '\'x\' is false instead of true'
-if not (1, 1): raise TestFailed, '(1, 1) is false instead of true'
-if not [1]: raise TestFailed, '[1] is false instead of true'
-if not {'x': 1}: raise TestFailed, '{\'x\': 1} is false instead of true'
-def f(): pass
-class C: pass
-import sys
-x = C()
-if not f: raise TestFailed, 'f is false instead of true'
-if not C: raise TestFailed, 'C is false instead of true'
-if not sys: raise TestFailed, 'sys is false instead of true'
-if not x: raise TestFailed, 'x is false instead of true'
-
-print '6.2 Boolean operations'
-if 0 or 0: raise TestFailed, '0 or 0 is true instead of false'
-if 1 and 1: pass
-else: raise TestFailed, '1 and 1 is false instead of false'
-if not 1: raise TestFailed, 'not 1 is true instead of false'
-
-print '6.3 Comparisons'
-if 0 < 1 <= 1 == 1 >= 1 > 0 <> 1: pass
-else: raise TestFailed, 'int comparisons failed'
-if 0L < 1L <= 1L == 1L >= 1L > 0L <> 1L: pass
-else: raise TestFailed, 'long int comparisons failed'
-if 0.0 < 1.0 <= 1.0 == 1.0 >= 1.0 > 0.0 <> 1.0: pass
-else: raise TestFailed, 'float comparisons failed'
-if '' < 'a' <= 'a' == 'a' < 'abc' < 'abd' < 'b': pass
-else: raise TestFailed, 'string comparisons failed'
-if 0 in [0] and 0 not in [1]: pass
-else: raise TestFailed, 'membership test failed'
-if None is None and [] is not []: pass
-else: raise TestFailed, 'identity test failed'
-
-print '6.4 Numeric types (mostly conversions)'
-if 0 <> 0L or 0 <> 0.0 or 0L <> 0.0: raise TestFailed, 'mixed comparisons'
-if 1 <> 1L or 1 <> 1.0 or 1L <> 1.0: raise TestFailed, 'mixed comparisons'
-if -1 <> -1L or -1 <> -1.0 or -1L <> -1.0:
- raise TestFailed, 'int/long/float value not equal'
-if int(1.9) == 1 == int(1.1) and int(-1.1) == -1 == int(-1.9): pass
-else: raise TestFailed, 'int() does not round properly'
-if long(1.9) == 1L == long(1.1) and long(-1.1) == -1L == long(-1.9): pass
-else: raise TestFailed, 'long() does not round properly'
-if float(1) == 1.0 and float(-1) == -1.0 and float(0) == 0.0: pass
-else: raise TestFailed, 'float() does not work properly'
-print '6.4.1 32-bit integers'
-if 12 + 24 <> 36: raise TestFailed, 'int op'
-if 12 + (-24) <> -12: raise TestFailed, 'int op'
-if (-12) + 24 <> 12: raise TestFailed, 'int op'
-if (-12) + (-24) <> -36: raise TestFailed, 'int op'
-if not 12 < 24: raise TestFailed, 'int op'
-if not -24 < -12: raise TestFailed, 'int op'
-# Test for a particular bug in integer multiply
-xsize, ysize, zsize = 238, 356, 4
-if not (xsize*ysize*zsize == zsize*xsize*ysize == 338912):
- raise TestFailed, 'int mul commutativity'
-print '6.4.2 Long integers'
-if 12L + 24L <> 36L: raise TestFailed, 'long op'
-if 12L + (-24L) <> -12L: raise TestFailed, 'long op'
-if (-12L) + 24L <> 12L: raise TestFailed, 'long op'
-if (-12L) + (-24L) <> -36L: raise TestFailed, 'long op'
-if not 12L < 24L: raise TestFailed, 'long op'
-if not -24L < -12L: raise TestFailed, 'long op'
-x = sys.maxint
-if int(long(x)) != x: raise TestFailed, 'long op'
-try: int(long(x)+1L)
-except OverflowError: pass
-else:raise TestFailed, 'long op'
-x = -x
-if int(long(x)) != x: raise TestFailed, 'long op'
-x = x-1
-if int(long(x)) != x: raise TestFailed, 'long op'
-try: int(long(x)-1L)
-except OverflowError: pass
-else:raise TestFailed, 'long op'
-print '6.4.3 Floating point numbers'
-if 12.0 + 24.0 <> 36.0: raise TestFailed, 'float op'
-if 12.0 + (-24.0) <> -12.0: raise TestFailed, 'float op'
-if (-12.0) + 24.0 <> 12.0: raise TestFailed, 'float op'
-if (-12.0) + (-24.0) <> -36.0: raise TestFailed, 'float op'
-if not 12.0 < 24.0: raise TestFailed, 'float op'
-if not -24.0 < -12.0: raise TestFailed, 'float op'
-
-print '6.5 Sequence types'
-
-print '6.5.1 Strings'
-if len('') <> 0: raise TestFailed, 'len(\'\')'
-if len('a') <> 1: raise TestFailed, 'len(\'a\')'
-if len('abcdef') <> 6: raise TestFailed, 'len(\'abcdef\')'
-if 'xyz' + 'abcde' <> 'xyzabcde': raise TestFailed, 'string concatenation'
-if 'xyz'*3 <> 'xyzxyzxyz': raise TestFailed, 'string repetition *3'
-if 0*'abcde' <> '': raise TestFailed, 'string repetition 0*'
-if min('abc') <> 'a' or max('abc') <> 'c': raise TestFailed, 'min/max string'
-if 'a' in 'abc' and 'b' in 'abc' and 'c' in 'abc' and 'd' not in 'abc': pass
-else: raise TestFailed, 'in/not in string'
-x = 'x'*103
-if '%s!'%x != x+'!': raise TestFailed, 'nasty string formatting bug'
-
-print '6.5.2 Tuples'
-if len(()) <> 0: raise TestFailed, 'len(())'
-if len((1,)) <> 1: raise TestFailed, 'len((1,))'
-if len((1,2,3,4,5,6)) <> 6: raise TestFailed, 'len((1,2,3,4,5,6))'
-if (1,2)+(3,4) <> (1,2,3,4): raise TestFailed, 'tuple concatenation'
-if (1,2)*3 <> (1,2,1,2,1,2): raise TestFailed, 'tuple repetition *3'
-if 0*(1,2,3) <> (): raise TestFailed, 'tuple repetition 0*'
-if min((1,2)) <> 1 or max((1,2)) <> 2: raise TestFailed, 'min/max tuple'
-if 0 in (0,1,2) and 1 in (0,1,2) and 2 in (0,1,2) and 3 not in (0,1,2): pass
-else: raise TestFailed, 'in/not in tuple'
-
-print '6.5.3 Lists'
-if len([]) <> 0: raise TestFailed, 'len([])'
-if len([1,]) <> 1: raise TestFailed, 'len([1,])'
-if len([1,2,3,4,5,6]) <> 6: raise TestFailed, 'len([1,2,3,4,5,6])'
-if [1,2]+[3,4] <> [1,2,3,4]: raise TestFailed, 'list concatenation'
-if [1,2]*3 <> [1,2,1,2,1,2]: raise TestFailed, 'list repetition *3'
-if [1,2]*3L <> [1,2,1,2,1,2]: raise TestFailed, 'list repetition *3L'
-if 0*[1,2,3] <> []: raise TestFailed, 'list repetition 0*'
-if 0L*[1,2,3] <> []: raise TestFailed, 'list repetition 0L*'
-if min([1,2]) <> 1 or max([1,2]) <> 2: raise TestFailed, 'min/max list'
-if 0 in [0,1,2] and 1 in [0,1,2] and 2 in [0,1,2] and 3 not in [0,1,2]: pass
-else: raise TestFailed, 'in/not in list'
-a = [1, 2, 3, 4, 5]
-a[:-1] = a
-if a != [1, 2, 3, 4, 5, 5]:
- raise TestFailed, "list self-slice-assign (head)"
-a = [1, 2, 3, 4, 5]
-a[1:] = a
-if a != [1, 1, 2, 3, 4, 5]:
- raise TestFailed, "list self-slice-assign (tail)"
-a = [1, 2, 3, 4, 5]
-a[1:-1] = a
-if a != [1, 1, 2, 3, 4, 5, 5]:
- raise TestFailed, "list self-slice-assign (center)"
-
-
-print '6.5.3a Additional list operations'
-a = [0,1,2,3,4]
-a[0L] = 1
-a[1L] = 2
-a[2L] = 3
-if a <> [1,2,3,3,4]: raise TestFailed, 'list item assignment [0L], [1L], [2L]'
-a[0] = 5
-a[1] = 6
-a[2] = 7
-if a <> [5,6,7,3,4]: raise TestFailed, 'list item assignment [0], [1], [2]'
-a[-2L] = 88
-a[-1L] = 99
-if a <> [5,6,7,88,99]: raise TestFailed, 'list item assignment [-2L], [-1L]'
-a[-2] = 8
-a[-1] = 9
-if a <> [5,6,7,8,9]: raise TestFailed, 'list item assignment [-2], [-1]'
-a[:2] = [0,4]
-a[-3:] = []
-a[1:1] = [1,2,3]
-if a <> [0,1,2,3,4]: raise TestFailed, 'list slice assignment'
-a[ 1L : 4L] = [7,8,9]
-if a <> [0,7,8,9,4]: raise TestFailed, 'list slice assignment using long ints'
-del a[1:4]
-if a <> [0,4]: raise TestFailed, 'list slice deletion'
-del a[0]
-if a <> [4]: raise TestFailed, 'list item deletion [0]'
-del a[-1]
-if a <> []: raise TestFailed, 'list item deletion [-1]'
-a=range(0,5)
-del a[1L:4L]
-if a <> [0,4]: raise TestFailed, 'list slice deletion'
-del a[0L]
-if a <> [4]: raise TestFailed, 'list item deletion [0]'
-del a[-1L]
-if a <> []: raise TestFailed, 'list item deletion [-1]'
-a.append(0)
-a.append(1)
-a.append(2)
-if a <> [0,1,2]: raise TestFailed, 'list append'
-a.insert(0, -2)
-a.insert(1, -1)
-a.insert(2,0)
-if a <> [-2,-1,0,0,1,2]: raise TestFailed, 'list insert'
-if a.count(0) <> 2: raise TestFailed, ' list count'
-if a.index(0) <> 2: raise TestFailed, 'list index'
-a.remove(0)
-if a <> [-2,-1,0,1,2]: raise TestFailed, 'list remove'
-a.reverse()
-if a <> [2,1,0,-1,-2]: raise TestFailed, 'list reverse'
-a.sort()
-if a <> [-2,-1,0,1,2]: raise TestFailed, 'list sort'
-def revcmp(a, b): return cmp(b, a)
-a.sort(revcmp)
-if a <> [2,1,0,-1,-2]: raise TestFailed, 'list sort with cmp func'
-# 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)
-
-# Test extreme cases with long ints
-a = [0,1,2,3,4]
-if a[ -pow(2,128L): 3 ] != [0,1,2]:
- raise TestFailed, "list slicing with too-small long integer"
-if a[ 3: pow(2,145L) ] != [3,4]:
- raise TestFailed, "list slicing with too-large long integer"
-
-print '6.6 Mappings == Dictionaries'
-d = {}
-if d.keys() <> []: raise TestFailed, '{}.keys()'
-if d.has_key('a') <> 0: raise TestFailed, '{}.has_key(\'a\')'
-if len(d) <> 0: raise TestFailed, 'len({})'
-d = {'a': 1, 'b': 2}
-if len(d) <> 2: raise TestFailed, 'len(dict)'
-k = d.keys()
-k.sort()
-if k <> ['a', 'b']: raise TestFailed, 'dict keys()'
-if d.has_key('a') and d.has_key('b') and not d.has_key('c'): pass
-else: raise TestFailed, 'dict keys()'
-if d['a'] <> 1 or d['b'] <> 2: raise TestFailed, 'dict item'
-d['c'] = 3
-d['a'] = 4
-if d['c'] <> 3 or d['a'] <> 4: raise TestFailed, 'dict item assignment'
-del d['b']
-if d <> {'a': 4, 'c': 3}: raise TestFailed, 'dict item deletion'
-d = {1:1, 2:2, 3:3}
-d.clear()
-if d != {}: raise TestFailed, 'dict clear'
-d.update({1:100})
-d.update({2:20})
-d.update({1:1, 2:2, 3:3})
-if d != {1:1, 2:2, 3:3}: raise TestFailed, 'dict update'
-if d.copy() != {1:1, 2:2, 3:3}: raise TestFailed, 'dict copy'
-if {}.copy() != {}: raise TestFailed, 'empty dict copy'
-# dict.get()
-d = {}
-if d.get('c') != None: raise TestFailed, 'missing {} get, no 2nd arg'
-if d.get('c', 3) != 3: raise TestFailed, 'missing {} get, w/ 2nd arg'
-d = {'a' : 1, 'b' : 2}
-if d.get('c') != None: raise TestFailed, 'missing dict get, no 2nd arg'
-if d.get('c', 3) != 3: raise TestFailed, 'missing dict get, w/ 2nd arg'
-if d.get('a') != 1: raise TestFailed, 'present dict get, no 2nd arg'
-if d.get('a', 3) != 1: raise TestFailed, 'present dict get, w/ 2nd arg'
-# dict.setdefault()
-d = {}
-if d.setdefault('key0') <> None:
- raise TestFailed, 'missing {} setdefault, no 2nd arg'
-if d.setdefault('key0') <> None:
- raise TestFailed, 'present {} setdefault, no 2nd arg'
-d.setdefault('key', []).append(3)
-if d['key'][0] <> 3:
- raise TestFailed, 'missing {} setdefault, w/ 2nd arg'
-d.setdefault('key', []).append(4)
-if len(d['key']) <> 2:
- raise TestFailed, 'present {} setdefault, w/ 2nd arg'
diff --git a/Lib/dos-8x3/test_uni.py b/Lib/dos-8x3/test_uni.py
deleted file mode 100644
index 0c44fbf..0000000
--- a/Lib/dos-8x3/test_uni.py
+++ /dev/null
@@ -1,518 +0,0 @@
-""" Test script for the Unicode implementation.
-
-Written by Marc-Andre Lemburg (mal@lemburg.com).
-
-(c) Copyright CNRI, All Rights Reserved. NO WARRANTY.
-
-"""
-from test_support import verbose
-import sys
-
-def test(method, input, output, *args):
- if verbose:
- print '%s.%s%s =? %s... ' % (repr(input), method, args, output),
- try:
- f = getattr(input, method)
- value = apply(f, args)
- except:
- value = sys.exc_type
- exc = sys.exc_info()[:2]
- else:
- exc = None
- if value != output:
- if verbose:
- print 'no'
- print '*',f, `input`, `output`, `value`
- if exc:
- print ' value == %s: %s' % (exc)
- else:
- if verbose:
- print 'yes'
-
-test('capitalize', u' hello ', u' hello ')
-test('capitalize', u'hello ', u'Hello ')
-
-test('title', u' hello ', u' Hello ')
-test('title', u'hello ', u'Hello ')
-test('title', u"fOrMaT thIs aS titLe String", u'Format This As Title String')
-test('title', u"fOrMaT,thIs-aS*titLe;String", u'Format,This-As*Title;String')
-test('title', u"getInt", u'Getint')
-
-test('find', u'abcdefghiabc', 0, u'abc')
-test('find', u'abcdefghiabc', 9, u'abc', 1)
-test('find', u'abcdefghiabc', -1, u'def', 4)
-
-test('rfind', u'abcdefghiabc', 9, u'abc')
-
-test('lower', u'HeLLo', u'hello')
-test('lower', u'hello', u'hello')
-
-test('upper', u'HeLLo', u'HELLO')
-test('upper', u'HELLO', u'HELLO')
-
-if 0:
- transtable = '\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037 !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`xyzdefghijklmnopqrstuvwxyz{|}~\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377'
-
- test('maketrans', u'abc', transtable, u'xyz')
- test('maketrans', u'abc', ValueError, u'xyzq')
-
-test('split', u'this is the split function',
- [u'this', u'is', u'the', u'split', u'function'])
-test('split', u'a|b|c|d', [u'a', u'b', u'c', u'd'], u'|')
-test('split', u'a|b|c|d', [u'a', u'b', u'c|d'], u'|', 2)
-test('split', u'a b c d', [u'a', u'b c d'], None, 1)
-test('split', u'a b c d', [u'a', u'b', u'c d'], None, 2)
-test('split', u'a b c d', [u'a', u'b', u'c', u'd'], None, 3)
-test('split', u'a b c d', [u'a', u'b', u'c', u'd'], None, 4)
-test('split', u'a b c d', [u'a b c d'], None, 0)
-test('split', u'a b c d', [u'a', u'b', u'c d'], None, 2)
-test('split', u'a b c d ', [u'a', u'b', u'c', u'd'])
-
-# join now works with any sequence type
-class Sequence:
- def __init__(self): self.seq = 'wxyz'
- def __len__(self): return len(self.seq)
- def __getitem__(self, i): return self.seq[i]
-
-test('join', u' ', u'a b c d', [u'a', u'b', u'c', u'd'])
-test('join', u'', u'abcd', (u'a', u'b', u'c', u'd'))
-test('join', u' ', u'w x y z', Sequence())
-test('join', u' ', TypeError, 7)
-
-class BadSeq(Sequence):
- def __init__(self): self.seq = [7, u'hello', 123L]
-
-test('join', u' ', TypeError, BadSeq())
-
-result = u''
-for i in range(10):
- if i > 0:
- result = result + u':'
- result = result + u'x'*10
-test('join', u':', result, [u'x' * 10] * 10)
-test('join', u':', result, (u'x' * 10,) * 10)
-
-test('strip', u' hello ', u'hello')
-test('lstrip', u' hello ', u'hello ')
-test('rstrip', u' hello ', u' hello')
-test('strip', u'hello', u'hello')
-
-test('swapcase', u'HeLLo cOmpUteRs', u'hEllO CoMPuTErS')
-
-if 0:
- test('translate', u'xyzabcdef', u'xyzxyz', transtable, u'def')
-
- table = string.maketrans('a', u'A')
- test('translate', u'abc', u'Abc', table)
- test('translate', u'xyz', u'xyz', table)
-
-test('replace', u'one!two!three!', u'one@two!three!', u'!', u'@', 1)
-test('replace', u'one!two!three!', u'onetwothree', '!', '')
-test('replace', u'one!two!three!', u'one@two@three!', u'!', u'@', 2)
-test('replace', u'one!two!three!', u'one@two@three@', u'!', u'@', 3)
-test('replace', u'one!two!three!', u'one@two@three@', u'!', u'@', 4)
-test('replace', u'one!two!three!', u'one!two!three!', u'!', u'@', 0)
-test('replace', u'one!two!three!', u'one@two@three@', u'!', u'@')
-test('replace', u'one!two!three!', u'one!two!three!', u'x', u'@')
-test('replace', u'one!two!three!', u'one!two!three!', u'x', u'@', 2)
-
-test('startswith', u'hello', 1, u'he')
-test('startswith', u'hello', 1, u'hello')
-test('startswith', u'hello', 0, u'hello world')
-test('startswith', u'hello', 1, u'')
-test('startswith', u'hello', 0, u'ello')
-test('startswith', u'hello', 1, u'ello', 1)
-test('startswith', u'hello', 1, u'o', 4)
-test('startswith', u'hello', 0, u'o', 5)
-test('startswith', u'hello', 1, u'', 5)
-test('startswith', u'hello', 0, u'lo', 6)
-test('startswith', u'helloworld', 1, u'lowo', 3)
-test('startswith', u'helloworld', 1, u'lowo', 3, 7)
-test('startswith', u'helloworld', 0, u'lowo', 3, 6)
-
-test('endswith', u'hello', 1, u'lo')
-test('endswith', u'hello', 0, u'he')
-test('endswith', u'hello', 1, u'')
-test('endswith', u'hello', 0, u'hello world')
-test('endswith', u'helloworld', 0, u'worl')
-test('endswith', u'helloworld', 1, u'worl', 3, 9)
-test('endswith', u'helloworld', 1, u'world', 3, 12)
-test('endswith', u'helloworld', 1, u'lowo', 1, 7)
-test('endswith', u'helloworld', 1, u'lowo', 2, 7)
-test('endswith', u'helloworld', 1, u'lowo', 3, 7)
-test('endswith', u'helloworld', 0, u'lowo', 4, 7)
-test('endswith', u'helloworld', 0, u'lowo', 3, 8)
-test('endswith', u'ab', 0, u'ab', 0, 1)
-test('endswith', u'ab', 0, u'ab', 0, 0)
-
-test('expandtabs', u'abc\rab\tdef\ng\thi', u'abc\rab def\ng hi')
-test('expandtabs', u'abc\rab\tdef\ng\thi', u'abc\rab def\ng hi', 8)
-test('expandtabs', u'abc\rab\tdef\ng\thi', u'abc\rab def\ng hi', 4)
-test('expandtabs', u'abc\r\nab\tdef\ng\thi', u'abc\r\nab def\ng hi', 4)
-
-if 0:
- test('capwords', u'abc def ghi', u'Abc Def Ghi')
- test('capwords', u'abc\tdef\nghi', u'Abc Def Ghi')
- test('capwords', u'abc\t def \nghi', u'Abc Def Ghi')
-
-# Comparisons:
-print 'Testing Unicode comparisons...',
-assert u'abc' == 'abc'
-assert 'abc' == u'abc'
-assert u'abc' == u'abc'
-assert u'abcd' > 'abc'
-assert 'abcd' > u'abc'
-assert u'abcd' > u'abc'
-assert u'abc' < 'abcd'
-assert 'abc' < u'abcd'
-assert u'abc' < u'abcd'
-print 'done.'
-
-if 0:
- # Move these tests to a Unicode collation module test...
-
- print 'Testing UTF-16 code point order comparisons...',
- #No surrogates, no fixup required.
- assert u'\u0061' < u'\u20ac'
- # Non surrogate below surrogate value, no fixup required
- assert u'\u0061' < u'\ud800\udc02'
-
- # Non surrogate above surrogate value, fixup required
- def test_lecmp(s, s2):
- assert s < s2 , "comparison failed on %s < %s" % (s, s2)
-
- def test_fixup(s):
- s2 = u'\ud800\udc01'
- test_lecmp(s, s2)
- s2 = u'\ud900\udc01'
- test_lecmp(s, s2)
- s2 = u'\uda00\udc01'
- test_lecmp(s, s2)
- s2 = u'\udb00\udc01'
- test_lecmp(s, s2)
- s2 = u'\ud800\udd01'
- test_lecmp(s, s2)
- s2 = u'\ud900\udd01'
- test_lecmp(s, s2)
- s2 = u'\uda00\udd01'
- test_lecmp(s, s2)
- s2 = u'\udb00\udd01'
- test_lecmp(s, s2)
- s2 = u'\ud800\ude01'
- test_lecmp(s, s2)
- s2 = u'\ud900\ude01'
- test_lecmp(s, s2)
- s2 = u'\uda00\ude01'
- test_lecmp(s, s2)
- s2 = u'\udb00\ude01'
- test_lecmp(s, s2)
- s2 = u'\ud800\udfff'
- test_lecmp(s, s2)
- s2 = u'\ud900\udfff'
- test_lecmp(s, s2)
- s2 = u'\uda00\udfff'
- test_lecmp(s, s2)
- s2 = u'\udb00\udfff'
- test_lecmp(s, s2)
-
- test_fixup(u'\ue000')
- test_fixup(u'\uff61')
-
- # Surrogates on both sides, no fixup required
- assert u'\ud800\udc02' < u'\ud84d\udc56'
- print 'done.'
-
-test('ljust', u'abc', u'abc ', 10)
-test('rjust', u'abc', u' abc', 10)
-test('center', u'abc', u' abc ', 10)
-test('ljust', u'abc', u'abc ', 6)
-test('rjust', u'abc', u' abc', 6)
-test('center', u'abc', u' abc ', 6)
-test('ljust', u'abc', u'abc', 2)
-test('rjust', u'abc', u'abc', 2)
-test('center', u'abc', u'abc', 2)
-
-test('islower', u'a', 1)
-test('islower', u'A', 0)
-test('islower', u'\n', 0)
-test('islower', u'\u1FFc', 0)
-test('islower', u'abc', 1)
-test('islower', u'aBc', 0)
-test('islower', u'abc\n', 1)
-
-test('isupper', u'a', 0)
-test('isupper', u'A', 1)
-test('isupper', u'\n', 0)
-test('isupper', u'\u1FFc', 0)
-test('isupper', u'ABC', 1)
-test('isupper', u'AbC', 0)
-test('isupper', u'ABC\n', 1)
-
-test('istitle', u'a', 0)
-test('istitle', u'A', 1)
-test('istitle', u'\n', 0)
-test('istitle', u'\u1FFc', 1)
-test('istitle', u'A Titlecased Line', 1)
-test('istitle', u'A\nTitlecased Line', 1)
-test('istitle', u'A Titlecased, Line', 1)
-test('istitle', u'Greek \u1FFcitlecases ...', 1)
-test('istitle', u'Not a capitalized String', 0)
-test('istitle', u'Not\ta Titlecase String', 0)
-test('istitle', u'Not--a Titlecase String', 0)
-
-test('isalpha', u'a', 1)
-test('isalpha', u'A', 1)
-test('isalpha', u'\n', 0)
-test('isalpha', u'\u1FFc', 1)
-test('isalpha', u'abc', 1)
-test('isalpha', u'aBc123', 0)
-test('isalpha', u'abc\n', 0)
-
-test('isalnum', u'a', 1)
-test('isalnum', u'A', 1)
-test('isalnum', u'\n', 0)
-test('isalnum', u'123abc456', 1)
-test('isalnum', u'a1b3c', 1)
-test('isalnum', u'aBc000 ', 0)
-test('isalnum', u'abc\n', 0)
-
-test('splitlines', u"abc\ndef\n\rghi", [u'abc', u'def', u'', u'ghi'])
-test('splitlines', u"abc\ndef\n\r\nghi", [u'abc', u'def', u'', u'ghi'])
-test('splitlines', u"abc\ndef\r\nghi", [u'abc', u'def', u'ghi'])
-test('splitlines', u"abc\ndef\r\nghi\n", [u'abc', u'def', u'ghi'])
-test('splitlines', u"abc\ndef\r\nghi\n\r", [u'abc', u'def', u'ghi', u''])
-test('splitlines', u"\nabc\ndef\r\nghi\n\r", [u'', u'abc', u'def', u'ghi', u''])
-test('splitlines', u"\nabc\ndef\r\nghi\n\r", [u'\n', u'abc\n', u'def\r\n', u'ghi\n', u'\r'], 1)
-
-test('translate', u"abababc", u'bbbc', {ord('a'):None})
-test('translate', u"abababc", u'iiic', {ord('a'):None, ord('b'):ord('i')})
-test('translate', u"abababc", u'iiix', {ord('a'):None, ord('b'):ord('i'), ord('c'):u'x'})
-
-# Contains:
-print 'Testing Unicode contains method...',
-assert ('a' in u'abdb') == 1
-assert ('a' in u'bdab') == 1
-assert ('a' in u'bdaba') == 1
-assert ('a' in u'bdba') == 1
-assert ('a' in u'bdba') == 1
-assert (u'a' in u'bdba') == 1
-assert (u'a' in u'bdb') == 0
-assert (u'a' in 'bdb') == 0
-assert (u'a' in 'bdba') == 1
-assert (u'a' in ('a',1,None)) == 1
-assert (u'a' in (1,None,'a')) == 1
-assert (u'a' in (1,None,u'a')) == 1
-assert ('a' in ('a',1,None)) == 1
-assert ('a' in (1,None,'a')) == 1
-assert ('a' in (1,None,u'a')) == 1
-assert ('a' in ('x',1,u'y')) == 0
-assert ('a' in ('x',1,None)) == 0
-print 'done.'
-
-# Formatting:
-print 'Testing Unicode formatting strings...',
-assert u"%s, %s" % (u"abc", "abc") == u'abc, abc'
-assert u"%s, %s, %i, %f, %5.2f" % (u"abc", "abc", 1, 2, 3) == u'abc, abc, 1, 2.000000, 3.00'
-assert u"%s, %s, %i, %f, %5.2f" % (u"abc", "abc", 1, -2, 3) == u'abc, abc, 1, -2.000000, 3.00'
-assert u"%s, %s, %i, %f, %5.2f" % (u"abc", "abc", -1, -2, 3.5) == u'abc, abc, -1, -2.000000, 3.50'
-assert u"%s, %s, %i, %f, %5.2f" % (u"abc", "abc", -1, -2, 3.57) == u'abc, abc, -1, -2.000000, 3.57'
-assert u"%s, %s, %i, %f, %5.2f" % (u"abc", "abc", -1, -2, 1003.57) == u'abc, abc, -1, -2.000000, 1003.57'
-assert u"%c" % (u"a",) == u'a'
-assert u"%c" % ("a",) == u'a'
-assert u"%c" % (34,) == u'"'
-assert u"%c" % (36,) == u'$'
-value = u"%r, %r" % (u"abc", "abc")
-if value != u"u'abc', 'abc'":
- print '*** formatting failed for "%s"' % 'u"%r, %r" % (u"abc", "abc")'
-
-assert u"%(x)s, %(y)s" % {'x':u"abc", 'y':"def"} == u'abc, def'
-try:
- value = u"%(x)s, %(ä)s" % {'x':u"abc", u'ä'.encode('utf-8'):"def"}
-except KeyError:
- print '*** formatting failed for "%s"' % "u'abc, def'"
-else:
- assert value == u'abc, def'
-
-# formatting jobs delegated from the string implementation:
-assert '...%(foo)s...' % {'foo':u"abc"} == u'...abc...'
-assert '...%(foo)s...' % {'foo':"abc"} == '...abc...'
-assert '...%(foo)s...' % {u'foo':"abc"} == '...abc...'
-assert '...%(foo)s...' % {u'foo':u"abc"} == u'...abc...'
-assert '...%(foo)s...' % {u'foo':u"abc",'def':123} == u'...abc...'
-assert '...%(foo)s...' % {u'foo':u"abc",u'def':123} == u'...abc...'
-assert '...%s...%s...%s...%s...' % (1,2,3,u"abc") == u'...1...2...3...abc...'
-assert '...%%...%%s...%s...%s...%s...%s...' % (1,2,3,u"abc") == u'...%...%s...1...2...3...abc...'
-assert '...%s...' % u"abc" == u'...abc...'
-print 'done.'
-
-# Test builtin codecs
-print 'Testing builtin codecs...',
-
-# UTF-8 specific encoding tests:
-assert u'\u20ac'.encode('utf-8') == \
- ''.join((chr(0xe2), chr(0x82), chr(0xac)))
-assert u'\ud800\udc02'.encode('utf-8') == \
- ''.join((chr(0xf0), chr(0x90), chr(0x80), chr(0x82)))
-assert u'\ud84d\udc56'.encode('utf-8') == \
- ''.join((chr(0xf0), chr(0xa3), chr(0x91), chr(0x96)))
-# UTF-8 specific decoding tests
-assert unicode(''.join((chr(0xf0), chr(0xa3), chr(0x91), chr(0x96))),
- 'utf-8') == u'\ud84d\udc56'
-assert unicode(''.join((chr(0xf0), chr(0x90), chr(0x80), chr(0x82))),
- 'utf-8') == u'\ud800\udc02'
-assert unicode(''.join((chr(0xe2), chr(0x82), chr(0xac))),
- 'utf-8') == u'\u20ac'
-
-# Other possible utf-8 test cases:
-# * strict decoding testing for all of the
-# UTF8_ERROR cases in PyUnicode_DecodeUTF8
-
-
-
-assert unicode('hello','ascii') == u'hello'
-assert unicode('hello','utf-8') == u'hello'
-assert unicode('hello','utf8') == u'hello'
-assert unicode('hello','latin-1') == u'hello'
-
-class String:
- x = ''
- def __str__(self):
- return self.x
-
-o = String()
-
-o.x = 'abc'
-assert unicode(o) == u'abc'
-assert str(o) == 'abc'
-
-o.x = u'abc'
-assert unicode(o) == u'abc'
-assert str(o) == 'abc'
-
-try:
- u'Andr\202 x'.encode('ascii')
- u'Andr\202 x'.encode('ascii','strict')
-except ValueError:
- pass
-else:
- raise AssertionError, "u'Andr\202'.encode('ascii') failed to raise an exception"
-assert u'Andr\202 x'.encode('ascii','ignore') == "Andr x"
-assert u'Andr\202 x'.encode('ascii','replace') == "Andr? x"
-
-try:
- unicode('Andr\202 x','ascii')
- unicode('Andr\202 x','ascii','strict')
-except ValueError:
- pass
-else:
- raise AssertionError, "unicode('Andr\202') failed to raise an exception"
-assert unicode('Andr\202 x','ascii','ignore') == u"Andr x"
-assert unicode('Andr\202 x','ascii','replace') == u'Andr\uFFFD x'
-
-assert u'hello'.encode('ascii') == 'hello'
-assert u'hello'.encode('utf-8') == 'hello'
-assert u'hello'.encode('utf8') == 'hello'
-assert u'hello'.encode('utf-16-le') == 'h\000e\000l\000l\000o\000'
-assert u'hello'.encode('utf-16-be') == '\000h\000e\000l\000l\000o'
-assert u'hello'.encode('latin-1') == 'hello'
-
-u = u''.join(map(unichr, range(1024)))
-for encoding in ('utf-8', 'utf-16', 'utf-16-le', 'utf-16-be',
- 'raw_unicode_escape', 'unicode_escape', 'unicode_internal'):
- assert unicode(u.encode(encoding),encoding) == u
-
-u = u''.join(map(unichr, range(256)))
-for encoding in (
- 'latin-1',
- ):
- try:
- assert unicode(u.encode(encoding),encoding) == u
- except AssertionError:
- print '*** codec "%s" failed round-trip' % encoding
- except ValueError,why:
- print '*** codec for "%s" failed: %s' % (encoding, why)
-
-u = u''.join(map(unichr, range(128)))
-for encoding in (
- 'ascii',
- ):
- try:
- assert unicode(u.encode(encoding),encoding) == u
- except AssertionError:
- print '*** codec "%s" failed round-trip' % encoding
- except ValueError,why:
- print '*** codec for "%s" failed: %s' % (encoding, why)
-
-print 'done.'
-
-print 'Testing standard mapping codecs...',
-
-print '0-127...',
-s = ''.join(map(chr, range(128)))
-for encoding in (
- 'cp037', 'cp1026',
- 'cp437', 'cp500', 'cp737', 'cp775', 'cp850',
- 'cp852', 'cp855', 'cp860', 'cp861', 'cp862',
- 'cp863', 'cp865', 'cp866',
- 'iso8859_10', 'iso8859_13', 'iso8859_14', 'iso8859_15',
- 'iso8859_2', 'iso8859_3', 'iso8859_4', 'iso8859_5', 'iso8859_6',
- 'iso8859_7', 'iso8859_9', 'koi8_r', 'latin_1',
- 'mac_cyrillic', 'mac_latin2',
-
- 'cp1250', 'cp1251', 'cp1252', 'cp1253', 'cp1254', 'cp1255',
- 'cp1256', 'cp1257', 'cp1258',
- 'cp856', 'cp857', 'cp864', 'cp869', 'cp874',
-
- 'mac_greek', 'mac_iceland','mac_roman', 'mac_turkish',
- 'cp1006', 'cp875', 'iso8859_8',
-
- ### These have undefined mappings:
- #'cp424',
-
- ):
- try:
- assert unicode(s,encoding).encode(encoding) == s
- except AssertionError:
- print '*** codec "%s" failed round-trip' % encoding
- except ValueError,why:
- print '*** codec for "%s" failed: %s' % (encoding, why)
-
-print '128-255...',
-s = ''.join(map(chr, range(128,256)))
-for encoding in (
- 'cp037', 'cp1026',
- 'cp437', 'cp500', 'cp737', 'cp775', 'cp850',
- 'cp852', 'cp855', 'cp860', 'cp861', 'cp862',
- 'cp863', 'cp865', 'cp866',
- 'iso8859_10', 'iso8859_13', 'iso8859_14', 'iso8859_15',
- 'iso8859_2', 'iso8859_3', 'iso8859_4', 'iso8859_5', 'iso8859_6',
- 'iso8859_7', 'iso8859_9', 'koi8_r', 'latin_1',
- 'mac_cyrillic', 'mac_latin2',
-
- ### These have undefined mappings:
- #'cp1250', 'cp1251', 'cp1252', 'cp1253', 'cp1254', 'cp1255',
- #'cp1256', 'cp1257', 'cp1258',
- #'cp424', 'cp856', 'cp857', 'cp864', 'cp869', 'cp874',
- #'mac_greek', 'mac_iceland','mac_roman', 'mac_turkish',
-
- ### These fail the round-trip:
- #'cp1006', 'cp875', 'iso8859_8',
-
- ):
- try:
- assert unicode(s,encoding).encode(encoding) == s
- except AssertionError:
- print '*** codec "%s" failed round-trip' % encoding
- except ValueError,why:
- print '*** codec for "%s" failed: %s' % (encoding, why)
-
-print 'done.'
-
-print 'Testing Unicode string concatenation...',
-assert (u"abc" u"def") == u"abcdef"
-assert ("abc" u"def") == u"abcdef"
-assert (u"abc" "def") == u"abcdef"
-assert (u"abc" u"def" "ghi") == u"abcdefghi"
-assert ("abc" "def" u"ghi") == u"abcdefghi"
-print 'done.'
-
diff --git a/Lib/dos-8x3/test_unp.py b/Lib/dos-8x3/test_unp.py
deleted file mode 100644
index 25b94e9..0000000
--- a/Lib/dos-8x3/test_unp.py
+++ /dev/null
@@ -1,144 +0,0 @@
-from test_support import *
-
-t = (1, 2, 3)
-l = [4, 5, 6]
-
-class Seq:
- def __getitem__(self, i):
- if i >= 0 and i < 3: return i
- raise IndexError
-
-a = -1
-b = -1
-c = -1
-
-# unpack tuple
-if verbose:
- print 'unpack tuple'
-a, b, c = t
-if a <> 1 or b <> 2 or c <> 3:
- raise TestFailed
-
-# unpack list
-if verbose:
- print 'unpack list'
-a, b, c = l
-if a <> 4 or b <> 5 or c <> 6:
- raise TestFailed
-
-# unpack implied tuple
-if verbose:
- print 'unpack implied tuple'
-a, b, c = 7, 8, 9
-if a <> 7 or b <> 8 or c <> 9:
- raise TestFailed
-
-# unpack string... fun!
-if verbose:
- print 'unpack string'
-a, b, c = 'one'
-if a <> 'o' or b <> 'n' or c <> 'e':
- raise TestFailed
-
-# unpack generic sequence
-if verbose:
- print 'unpack sequence'
-a, b, c = Seq()
-if a <> 0 or b <> 1 or c <> 2:
- raise TestFailed
-
-# single element unpacking, with extra syntax
-if verbose:
- print 'unpack single tuple/list'
-st = (99,)
-sl = [100]
-a, = st
-if a <> 99:
- raise TestFailed
-b, = sl
-if b <> 100:
- raise TestFailed
-
-# now for some failures
-
-# unpacking non-sequence
-if verbose:
- print 'unpack non-sequence'
-try:
- a, b, c = 7
- raise TestFailed
-except TypeError:
- pass
-
-
-# unpacking tuple of wrong size
-if verbose:
- print 'unpack tuple wrong size'
-try:
- a, b = t
- raise TestFailed
-except ValueError:
- pass
-
-# unpacking list of wrong size
-if verbose:
- print 'unpack list wrong size'
-try:
- a, b = l
- raise TestFailed
-except ValueError:
- pass
-
-
-# unpacking sequence too short
-if verbose:
- print 'unpack sequence too short'
-try:
- a, b, c, d = Seq()
- raise TestFailed
-except ValueError:
- pass
-
-
-# unpacking sequence too long
-if verbose:
- print 'unpack sequence too long'
-try:
- a, b = Seq()
- raise TestFailed
-except ValueError:
- pass
-
-
-# unpacking a sequence where the test for too long raises a different
-# kind of error
-class BozoError(Exception):
- pass
-
-class BadSeq:
- def __getitem__(self, i):
- if i >= 0 and i < 3:
- return i
- elif i == 3:
- raise BozoError
- else:
- raise IndexError
-
-
-# trigger code while not expecting an IndexError
-if verbose:
- print 'unpack sequence too long, wrong error'
-try:
- a, b, c, d, e = BadSeq()
- raise TestFailed
-except BozoError:
- pass
-
-# trigger code while expecting an IndexError
-if verbose:
- print 'unpack sequence too short, wrong error'
-try:
- a, b, c = BadSeq()
- raise TestFailed
-except BozoError:
- pass
diff --git a/Lib/dos-8x3/test_url.py b/Lib/dos-8x3/test_url.py
deleted file mode 100644
index 484acea..0000000
--- a/Lib/dos-8x3/test_url.py
+++ /dev/null
@@ -1,32 +0,0 @@
-# Minimal test of the quote function
-import urllib
-
-chars = 'abcdefghijklmnopqrstuvwxyz'\
- '\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356' \
- '\357\360\361\362\363\364\365\366\370\371\372\373\374\375\376\377' \
- 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' \
- '\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317' \
- '\320\321\322\323\324\325\326\330\331\332\333\334\335\336'
-
-expected = 'abcdefghijklmnopqrstuvwxyz%df%e0%e1%e2%e3%e4%e5%e6%e7%e8%e9%ea%eb%ec%ed%ee%ef%f0%f1%f2%f3%f4%f5%f6%f8%f9%fa%fb%fc%fd%fe%ffABCDEFGHIJKLMNOPQRSTUVWXYZ%c0%c1%c2%c3%c4%c5%c6%c7%c8%c9%ca%cb%cc%cd%ce%cf%d0%d1%d2%d3%d4%d5%d6%d8%d9%da%db%dc%dd%de'
-
-test = urllib.quote(chars)
-assert test == expected, "urllib.quote problem"
-test2 = urllib.unquote(expected)
-assert test2 == chars
-
-in1 = "abc/def"
-out1_1 = "abc/def"
-out1_2 = "abc%2fdef"
-
-assert urllib.quote(in1) == out1_1, "urllib.quote problem"
-assert urllib.quote(in1, '') == out1_2, "urllib.quote problem"
-
-in2 = "abc?def"
-out2_1 = "abc%3fdef"
-out2_2 = "abc?def"
-
-assert urllib.quote(in2) == out2_1, "urllib.quote problem"
-assert urllib.quote(in2, '?') == out2_2, "urllib.quote problem"
-
-
diff --git a/Lib/dos-8x3/test_use.py b/Lib/dos-8x3/test_use.py
deleted file mode 100644
index 63632f7..0000000
--- a/Lib/dos-8x3/test_use.py
+++ /dev/null
@@ -1,101 +0,0 @@
-# Check every path through every method of UserDict
-
-from UserDict import UserDict
-
-d0 = {}
-d1 = {"one": 1}
-d2 = {"one": 1, "two": 2}
-
-# Test constructors
-
-u = UserDict()
-u0 = UserDict(d0)
-u1 = UserDict(d1)
-u2 = UserDict(d2)
-
-uu = UserDict(u)
-uu0 = UserDict(u0)
-uu1 = UserDict(u1)
-uu2 = UserDict(u2)
-
-# Test __repr__
-
-assert str(u0) == str(d0)
-assert repr(u1) == repr(d1)
-assert `u2` == `d2`
-
-# Test __cmp__ and __len__
-
-all = [d0, d1, d2, u, u0, u1, u2, uu, uu0, uu1, uu2]
-for a in all:
- for b in all:
- assert cmp(a, b) == cmp(len(a), len(b))
-
-# Test __getitem__
-
-assert u2["one"] == 1
-try:
- u1["two"]
-except KeyError:
- pass
-else:
- assert 0, "u1['two'] shouldn't exist"
-
-# Test __setitem__
-
-u3 = UserDict(u2)
-u3["two"] = 2
-u3["three"] = 3
-
-# Test __delitem__
-
-del u3["three"]
-try:
- del u3["three"]
-except KeyError:
- pass
-else:
- assert 0, "u3['three'] shouldn't exist"
-
-# Test clear
-
-u3.clear()
-assert u3 == {}
-
-# Test copy()
-
-u2a = u2.copy()
-assert u2a == u2
-
-class MyUserDict(UserDict):
- def display(self): print self
-
-m2 = MyUserDict(u2)
-m2a = m2.copy()
-assert m2a == m2
-
-# Test keys, items, values
-
-assert u2.keys() == d2.keys()
-assert u2.items() == d2.items()
-assert u2.values() == d2.values()
-
-# Test has_key
-
-for i in u2.keys():
- assert u2.has_key(i) == 1
- assert u1.has_key(i) == d1.has_key(i)
- assert u0.has_key(i) == d0.has_key(i)
-
-# Test update
-
-t = UserDict()
-t.update(u2)
-assert t == u2
-
-# Test get
-
-for i in u2.keys():
- assert u2.get(i) == u2[i]
- assert u1.get(i) == d1.get(i)
- assert u0.get(i) == d0.get(i)
diff --git a/Lib/dos-8x3/test_wav.py b/Lib/dos-8x3/test_wav.py
deleted file mode 100644
index a7a5e24..0000000
--- a/Lib/dos-8x3/test_wav.py
+++ /dev/null
@@ -1,34 +0,0 @@
-from test_support import TestFailed
-import os, tempfile
-import wave
-
-def check(t, msg=None):
- if not t:
- raise TestFailed, msg
-
-nchannels = 2
-sampwidth = 2
-framerate = 8000
-nframes = 100
-
-testfile = tempfile.mktemp()
-
-f = wave.open(testfile, 'w')
-f.setnchannels(nchannels)
-f.setsampwidth(sampwidth)
-f.setframerate(framerate)
-f.setnframes(nframes)
-output = '\0' * nframes * nchannels * sampwidth
-f.writeframes(output)
-f.close()
-
-f = wave.open(testfile, 'r')
-check(nchannels == f.getnchannels(), "nchannels")
-check(sampwidth == f.getsampwidth(), "sampwidth")
-check(framerate == f.getframerate(), "framerate")
-check(nframes == f.getnframes(), "nframes")
-input = f.readframes(nframes)
-check(input == output, "data")
-f.close()
-
-os.remove(testfile)
diff --git a/Lib/dos-8x3/test_win.py b/Lib/dos-8x3/test_win.py
deleted file mode 100644
index 18ce7a7..0000000
--- a/Lib/dos-8x3/test_win.py
+++ /dev/null
@@ -1,147 +0,0 @@
-# Test the windows specific win32reg module.
-# Only win32reg functions not hit here: FlushKey, LoadKey and SaveKey
-
-from _winreg import *
-import os, sys
-
-test_key_name = "SOFTWARE\\Python Registry Test Key - Delete Me"
-
-test_data = [
- ("Int Value", 45, REG_DWORD),
- ("String Val", "A string value", REG_SZ,),
- (u"Unicode Val", u"A Unicode value", REG_SZ,),
- ("StringExpand", "The path is %path%", REG_EXPAND_SZ),
- ("UnicodeExpand", u"The path is %path%", REG_EXPAND_SZ),
- ("Multi-string", ["Lots", "of", "string", "values"], REG_MULTI_SZ),
- ("Multi-unicode", [u"Lots", u"of", u"unicode", u"values"], REG_MULTI_SZ),
- ("Multi-mixed", [u"Unicode", u"and", "string", "values"],REG_MULTI_SZ),
- ("Raw Data", ("binary"+chr(0)+"data"), REG_BINARY),
-]
-
-def WriteTestData(root_key):
- # Set the default value for this key.
- SetValue(root_key, test_key_name, REG_SZ, "Default value")
- key = CreateKey(root_key, test_key_name)
- # Create a sub-key
- sub_key = CreateKey(key, "sub_key")
- # Give the sub-key some named values
-
- for value_name, value_data, value_type in test_data:
- SetValueEx(sub_key, value_name, 0, value_type, value_data)
-
- # Check we wrote as many items as we thought.
- nkeys, nvalues, since_mod = QueryInfoKey(key)
- assert nkeys==1, "Not the correct number of sub keys"
- assert nvalues==1, "Not the correct number of values"
- nkeys, nvalues, since_mod = QueryInfoKey(sub_key)
- assert nkeys==0, "Not the correct number of sub keys"
- assert nvalues==len(test_data), "Not the correct number of values"
- # Close this key this way...
- # (but before we do, copy the key as an integer - this allows
- # us to test that the key really gets closed).
- int_sub_key = int(sub_key)
- CloseKey(sub_key)
- try:
- QueryInfoKey(int_sub_key)
- raise RuntimeError, "It appears the CloseKey() function does not close the actual key!"
- except EnvironmentError:
- pass
- # ... and close that key that way :-)
- int_key = int(key)
- key.Close()
- try:
- QueryInfoKey(int_key)
- raise RuntimeError, "It appears the key.Close() function does not close the actual key!"
- except EnvironmentError:
- pass
-
-def ReadTestData(root_key):
- # Check we can get default value for this key.
- val = QueryValue(root_key, test_key_name)
- assert val=="Default value", "Registry didn't give back the correct value"
-
- key = OpenKey(root_key, test_key_name)
- # Read the sub-keys
- sub_key = OpenKey(key, "sub_key")
- # Check I can enumerate over the values.
- index = 0
- while 1:
- try:
- data = EnumValue(sub_key, index)
- except EnvironmentError:
- break
- assert data in test_data, "Didn't read back the correct test data"
- index = index + 1
- assert index==len(test_data), "Didn't read the correct number of items"
- # Check I can directly access each item
- for value_name, value_data, value_type in test_data:
- read_val, read_typ = QueryValueEx(sub_key, value_name)
- assert read_val==value_data and read_typ == value_type, \
- "Could not directly read the value"
- sub_key.Close()
- # Enumerate our main key.
- read_val = EnumKey(key, 0)
- assert read_val == "sub_key", "Read subkey value wrong"
- try:
- EnumKey(key, 1)
- assert 0, "Was able to get a second key when I only have one!"
- except EnvironmentError:
- pass
-
- key.Close()
-
-def DeleteTestData(root_key):
- key = OpenKey(root_key, test_key_name, 0, KEY_ALL_ACCESS)
- sub_key = OpenKey(key, "sub_key", 0, KEY_ALL_ACCESS)
- # It is not necessary to delete the values before deleting
- # the key (although subkeys must not exist). We delete them
- # manually just to prove we can :-)
- for value_name, value_data, value_type in test_data:
- DeleteValue(sub_key, value_name)
-
- nkeys, nvalues, since_mod = QueryInfoKey(sub_key)
- assert nkeys==0 and nvalues==0, "subkey not empty before delete"
- sub_key.Close()
- DeleteKey(key, "sub_key")
-
- try:
- # Shouldnt be able to delete it twice!
- DeleteKey(key, "sub_key")
- assert 0, "Deleting the key twice succeeded"
- except EnvironmentError:
- pass
- key.Close()
- DeleteKey(root_key, test_key_name)
- # Opening should now fail!
- try:
- key = OpenKey(root_key, test_key_name)
- assert 0, "Could open the non-existent key"
- except WindowsError: # Use this error name this time
- pass
-
-def TestAll(root_key):
- WriteTestData(root_key)
- ReadTestData(root_key)
- DeleteTestData(root_key)
-
-# Test on my local machine.
-TestAll(HKEY_CURRENT_USER)
-print "Local registry tests worked"
-try:
- remote_name = sys.argv[sys.argv.index("--remote")+1]
-except (IndexError, ValueError):
- remote_name = None
-
-if remote_name is not None:
- try:
- remote_key = ConnectRegistry(remote_name, HKEY_CURRENT_USER)
- except EnvironmentError, exc:
- print "Could not connect to the remote machine -", exc.strerror
- remote_key = None
- if remote_key is not None:
- TestAll(remote_key)
- print "Remote registry tests worked"
-else:
- print "Remote registry calls can be tested using",
- print "'test_winreg.py --remote \\\\machine_name'"
-
diff --git a/Lib/dos-8x3/test_xml.py b/Lib/dos-8x3/test_xml.py
deleted file mode 100644
index eb868a3..0000000
--- a/Lib/dos-8x3/test_xml.py
+++ /dev/null
@@ -1,25 +0,0 @@
-'''Test module to thest the xmllib module.
- Sjoerd Mullender
-'''
-
-from test_support import verbose
-
-testdoc = """\
-<?xml version="1.0" encoding="UTF-8" standalone='yes' ?>
-<!-- comments aren't allowed before the <?xml?> tag,
- but they are allowed before the <!DOCTYPE> tag -->
-<!DOCTYPE greeting [
- <!ELEMENT greeting (#PCDATA)>
-]>
-<greeting>Hello, world!</greeting>
-"""
-
-import xmllib
-if verbose:
- parser = xmllib.TestXMLParser()
-else:
- parser = xmllib.XMLParser()
-
-for c in testdoc:
- parser.feed(c)
-parser.close()
diff --git a/Lib/dos-8x3/test_zip.py b/Lib/dos-8x3/test_zip.py
deleted file mode 100644
index 3ffdd19..0000000
--- a/Lib/dos-8x3/test_zip.py
+++ /dev/null
@@ -1,26 +0,0 @@
-import zipfile, os
-
-srcname = "junk9630.tmp"
-zipname = "junk9708.tmp"
-
-try:
- fp = open(srcname, "w") # Make a source file with some lines
- for i in range(0, 1000):
- fp.write("Test of zipfile line %d.\n" % i)
- fp.close()
-
- zip = zipfile.ZipFile(zipname, "w") # Create the ZIP archive
- zip.write(srcname, srcname)
- zip.write(srcname, "another.name")
- zip.close()
-
- zip = zipfile.ZipFile(zipname, "r") # Read the ZIP archive
- zip.read("another.name")
- zip.read(srcname)
- zip.close()
-finally:
- if os.path.isfile(srcname): # Remove temporary files
- os.unlink(srcname)
- if os.path.isfile(zipname):
- os.unlink(zipname)
-
diff --git a/Lib/dos-8x3/test_zli.py b/Lib/dos-8x3/test_zli.py
deleted file mode 100644
index d22a2cc..0000000
--- a/Lib/dos-8x3/test_zli.py
+++ /dev/null
@@ -1,161 +0,0 @@
-import zlib
-import sys
-import imp
-import string
-
-try:
- t = imp.find_module('test_zlib')
- file = t[0]
-except ImportError:
- file = open(__file__)
-buf = file.read() * 8
-file.close()
-
-# test the checksums (hex so the test doesn't break on 64-bit machines)
-print hex(zlib.crc32('penguin')), hex(zlib.crc32('penguin', 1))
-print hex(zlib.adler32('penguin')), hex(zlib.adler32('penguin', 1))
-
-# make sure we generate some expected errors
-try:
- zlib.compress('ERROR', zlib.MAX_WBITS + 1)
-except zlib.error, msg:
- print "expecting", msg
-try:
- zlib.compressobj(1, 8, 0)
-except ValueError, msg:
- print "expecting", msg
-try:
- zlib.decompressobj(0)
-except ValueError, msg:
- print "expecting", msg
-
-x = zlib.compress(buf)
-y = zlib.decompress(x)
-if buf != y:
- print "normal compression/decompression failed"
-else:
- print "normal compression/decompression succeeded"
-
-buf = buf * 16
-
-co = zlib.compressobj(8, 8, -15)
-x1 = co.compress(buf)
-x2 = co.flush()
-x = x1 + x2
-
-dc = zlib.decompressobj(-15)
-y1 = dc.decompress(x)
-y2 = dc.flush()
-y = y1 + y2
-if buf != y:
- print "compress/decompression obj failed"
-else:
- print "compress/decompression obj succeeded"
-
-co = zlib.compressobj(2, 8, -12, 9, 1)
-bufs = []
-for i in range(0, len(buf), 256):
- bufs.append(co.compress(buf[i:i+256]))
-bufs.append(co.flush())
-combuf = string.join(bufs, '')
-
-decomp1 = zlib.decompress(combuf, -12, -5)
-if decomp1 != buf:
- print "decompress with init options failed"
-else:
- print "decompress with init options succeeded"
-
-deco = zlib.decompressobj(-12)
-bufs = []
-for i in range(0, len(combuf), 128):
- bufs.append(deco.decompress(combuf[i:i+128]))
-bufs.append(deco.flush())
-decomp2 = string.join(buf, '')
-if decomp2 != buf:
- print "decompressobj with init options failed"
-else:
- print "decompressobj with init options succeeded"
-
-# Test flush() with the various options, using all the different levels
-# in order to provide more variations.
-for sync in [zlib.Z_NO_FLUSH, zlib.Z_SYNC_FLUSH, zlib.Z_FULL_FLUSH]:
- for level in range(10):
- obj = zlib.compressobj( level )
- d = obj.compress( buf[:3000] )
- d = d + obj.flush( sync )
- d = d + obj.compress( buf[3000:] )
- d = d + obj.flush()
- if zlib.decompress(d) != buf:
- print "Decompress failed: flush mode=%i, level=%i" % (sync,level)
- del obj
-
-def ignore():
- """An empty function with a big string.
-
- Make the compression algorithm work a little harder.
- """
-
- """
-LAERTES
-
- O, fear me not.
- I stay too long: but here my father comes.
-
- Enter POLONIUS
-
- A double blessing is a double grace,
- Occasion smiles upon a second leave.
-
-LORD POLONIUS
-
- Yet here, Laertes! aboard, aboard, for shame!
- The wind sits in the shoulder of your sail,
- And you are stay'd for. There; my blessing with thee!
- And these few precepts in thy memory
- See thou character. Give thy thoughts no tongue,
- Nor any unproportioned thought his act.
- Be thou familiar, but by no means vulgar.
- Those friends thou hast, and their adoption tried,
- Grapple them to thy soul with hoops of steel;
- But do not dull thy palm with entertainment
- Of each new-hatch'd, unfledged comrade. Beware
- Of entrance to a quarrel, but being in,
- Bear't that the opposed may beware of thee.
- Give every man thy ear, but few thy voice;
- Take each man's censure, but reserve thy judgment.
- Costly thy habit as thy purse can buy,
- But not express'd in fancy; rich, not gaudy;
- For the apparel oft proclaims the man,
- And they in France of the best rank and station
- Are of a most select and generous chief in that.
- Neither a borrower nor a lender be;
- For loan oft loses both itself and friend,
- And borrowing dulls the edge of husbandry.
- This above all: to thine ownself be true,
- And it must follow, as the night the day,
- Thou canst not then be false to any man.
- Farewell: my blessing season this in thee!
-
-LAERTES
-
- Most humbly do I take my leave, my lord.
-
-LORD POLONIUS
-
- The time invites you; go; your servants tend.
-
-LAERTES
-
- Farewell, Ophelia; and remember well
- What I have said to you.
-
-OPHELIA
-
- 'Tis in my memory lock'd,
- And you yourself shall keep the key of it.
-
-LAERTES
-
- Farewell.
-"""
-
diff --git a/Lib/dos-8x3/threadin.py b/Lib/dos-8x3/threadin.py
deleted file mode 100644
index 4921f0e..0000000
--- a/Lib/dos-8x3/threadin.py
+++ /dev/null
@@ -1,631 +0,0 @@
-"""Proposed new threading module, emulating a subset of Java's threading model."""
-
-import sys
-import time
-import thread
-import traceback
-import StringIO
-
-# Rename some stuff so "from threading import *" is safe
-
-_sys = sys
-del sys
-
-_time = time.time
-_sleep = time.sleep
-del time
-
-_start_new_thread = thread.start_new_thread
-_allocate_lock = thread.allocate_lock
-_get_ident = thread.get_ident
-ThreadError = thread.error
-del thread
-
-_print_exc = traceback.print_exc
-del traceback
-
-_StringIO = StringIO.StringIO
-del StringIO
-
-
-# Debug support (adapted from ihooks.py)
-
-_VERBOSE = 0
-
-if __debug__:
-
- class _Verbose:
-
- def __init__(self, verbose=None):
- if verbose is None:
- verbose = _VERBOSE
- self.__verbose = verbose
-
- def _note(self, format, *args):
- if self.__verbose:
- format = format % args
- format = "%s: %s\n" % (
- currentThread().getName(), format)
- _sys.stderr.write(format)
-
-else:
- # Disable this when using "python -O"
- class _Verbose:
- def __init__(self, verbose=None):
- pass
- def _note(self, *args):
- pass
-
-
-# Synchronization classes
-
-Lock = _allocate_lock
-
-def RLock(*args, **kwargs):
- return apply(_RLock, args, kwargs)
-
-class _RLock(_Verbose):
-
- def __init__(self, verbose=None):
- _Verbose.__init__(self, verbose)
- self.__block = _allocate_lock()
- self.__owner = None
- self.__count = 0
-
- def __repr__(self):
- return "<%s(%s, %d)>" % (
- self.__class__.__name__,
- self.__owner and self.__owner.getName(),
- self.__count)
-
- def acquire(self, blocking=1):
- me = currentThread()
- if self.__owner is me:
- self.__count = self.__count + 1
- if __debug__:
- self._note("%s.acquire(%s): recursive success", self, blocking)
- return 1
- rc = self.__block.acquire(blocking)
- if rc:
- self.__owner = me
- self.__count = 1
- if __debug__:
- self._note("%s.acquire(%s): initial succes", self, blocking)
- else:
- if __debug__:
- self._note("%s.acquire(%s): failure", self, blocking)
- return rc
-
- def release(self):
- me = currentThread()
- assert self.__owner is me, "release() of un-acquire()d lock"
- self.__count = count = self.__count - 1
- if not count:
- self.__owner = None
- self.__block.release()
- if __debug__:
- self._note("%s.release(): final release", self)
- else:
- if __debug__:
- self._note("%s.release(): non-final release", self)
-
- # Internal methods used by condition variables
-
- def _acquire_restore(self, (count, owner)):
- self.__block.acquire()
- self.__count = count
- self.__owner = owner
- if __debug__:
- self._note("%s._acquire_restore()", self)
-
- def _release_save(self):
- if __debug__:
- self._note("%s._release_save()", self)
- count = self.__count
- self.__count = 0
- owner = self.__owner
- self.__owner = None
- self.__block.release()
- return (count, owner)
-
- def _is_owned(self):
- return self.__owner is currentThread()
-
-
-def Condition(*args, **kwargs):
- return apply(_Condition, args, kwargs)
-
-class _Condition(_Verbose):
-
- def __init__(self, lock=None, verbose=None):
- _Verbose.__init__(self, verbose)
- if lock is None:
- lock = RLock()
- self.__lock = lock
- # Export the lock's acquire() and release() methods
- self.acquire = lock.acquire
- self.release = lock.release
- # If the lock defines _release_save() and/or _acquire_restore(),
- # these override the default implementations (which just call
- # release() and acquire() on the lock). Ditto for _is_owned().
- try:
- self._release_save = lock._release_save
- except AttributeError:
- pass
- try:
- self._acquire_restore = lock._acquire_restore
- except AttributeError:
- pass
- try:
- self._is_owned = lock._is_owned
- except AttributeError:
- pass
- self.__waiters = []
-
- def __repr__(self):
- return "<Condition(%s, %d)>" % (self.__lock, len(self.__waiters))
-
- def _release_save(self):
- self.__lock.release() # No state to save
-
- def _acquire_restore(self, x):
- self.__lock.acquire() # Ignore saved state
-
- def _is_owned(self):
- if self.__lock.acquire(0):
- self.__lock.release()
- return 0
- else:
- return 1
-
- def wait(self, timeout=None):
- me = currentThread()
- assert self._is_owned(), "wait() of un-acquire()d lock"
- waiter = _allocate_lock()
- waiter.acquire()
- self.__waiters.append(waiter)
- saved_state = self._release_save()
- if timeout is None:
- waiter.acquire()
- if __debug__:
- self._note("%s.wait(): got it", self)
- else:
- endtime = _time() + timeout
- delay = 0.000001 # 1 usec
- while 1:
- gotit = waiter.acquire(0)
- if gotit or _time() >= endtime:
- break
- _sleep(delay)
- if delay < 1.0:
- delay = delay * 2.0
- if not gotit:
- if __debug__:
- self._note("%s.wait(%s): timed out", self, timeout)
- try:
- self.__waiters.remove(waiter)
- except ValueError:
- pass
- else:
- if __debug__:
- self._note("%s.wait(%s): got it", self, timeout)
- self._acquire_restore(saved_state)
-
- def notify(self, n=1):
- me = currentThread()
- assert self._is_owned(), "notify() of un-acquire()d lock"
- __waiters = self.__waiters
- waiters = __waiters[:n]
- if not waiters:
- if __debug__:
- self._note("%s.notify(): no waiters", self)
- return
- self._note("%s.notify(): notifying %d waiter%s", self, n,
- n!=1 and "s" or "")
- for waiter in waiters:
- waiter.release()
- try:
- __waiters.remove(waiter)
- except ValueError:
- pass
-
- def notifyAll(self):
- self.notify(len(self.__waiters))
-
-
-def Semaphore(*args, **kwargs):
- return apply(_Semaphore, args, kwargs)
-
-class _Semaphore(_Verbose):
-
- # After Tim Peters' semaphore class, but not quite the same (no maximum)
-
- def __init__(self, value=1, verbose=None):
- assert value >= 0, "Semaphore initial value must be >= 0"
- _Verbose.__init__(self, verbose)
- self.__cond = Condition(Lock())
- self.__value = value
-
- def acquire(self, blocking=1):
- rc = 0
- self.__cond.acquire()
- while self.__value == 0:
- if not blocking:
- break
- self.__cond.wait()
- else:
- self.__value = self.__value - 1
- rc = 1
- self.__cond.release()
- return rc
-
- def release(self):
- self.__cond.acquire()
- self.__value = self.__value + 1
- self.__cond.notify()
- self.__cond.release()
-
-
-def Event(*args, **kwargs):
- return apply(_Event, args, kwargs)
-
-class _Event(_Verbose):
-
- # After Tim Peters' event class (without is_posted())
-
- def __init__(self, verbose=None):
- _Verbose.__init__(self, verbose)
- self.__cond = Condition(Lock())
- self.__flag = 0
-
- def isSet(self):
- return self.__flag
-
- def set(self):
- self.__cond.acquire()
- self.__flag = 1
- self.__cond.notifyAll()
- self.__cond.release()
-
- def clear(self):
- self.__cond.acquire()
- self.__flag = 0
- self.__cond.release()
-
- def wait(self, timeout=None):
- self.__cond.acquire()
- if not self.__flag:
- self.__cond.wait(timeout)
- self.__cond.release()
-
-
-# Helper to generate new thread names
-_counter = 0
-def _newname(template="Thread-%d"):
- global _counter
- _counter = _counter + 1
- return template % _counter
-
-# Active thread administration
-_active_limbo_lock = _allocate_lock()
-_active = {}
-_limbo = {}
-
-
-# Main class for threads
-
-class Thread(_Verbose):
-
- __initialized = 0
-
- def __init__(self, group=None, target=None, name=None,
- args=(), kwargs={}, verbose=None):
- assert group is None, "group argument must be None for now"
- _Verbose.__init__(self, verbose)
- self.__target = target
- self.__name = str(name or _newname())
- self.__args = args
- self.__kwargs = kwargs
- self.__daemonic = self._set_daemon()
- self.__started = 0
- self.__stopped = 0
- self.__block = Condition(Lock())
- self.__initialized = 1
-
- def _set_daemon(self):
- # Overridden in _MainThread and _DummyThread
- return currentThread().isDaemon()
-
- def __repr__(self):
- assert self.__initialized, "Thread.__init__() was not called"
- status = "initial"
- if self.__started:
- status = "started"
- if self.__stopped:
- status = "stopped"
- if self.__daemonic:
- status = status + " daemon"
- return "<%s(%s, %s)>" % (self.__class__.__name__, self.__name, status)
-
- def start(self):
- assert self.__initialized, "Thread.__init__() not called"
- assert not self.__started, "thread already started"
- if __debug__:
- self._note("%s.start(): starting thread", self)
- _active_limbo_lock.acquire()
- _limbo[self] = self
- _active_limbo_lock.release()
- _start_new_thread(self.__bootstrap, ())
- self.__started = 1
- _sleep(0.000001) # 1 usec, to let the thread run (Solaris hack)
-
- def run(self):
- if self.__target:
- apply(self.__target, self.__args, self.__kwargs)
-
- def __bootstrap(self):
- try:
- self.__started = 1
- _active_limbo_lock.acquire()
- _active[_get_ident()] = self
- del _limbo[self]
- _active_limbo_lock.release()
- if __debug__:
- self._note("%s.__bootstrap(): thread started", self)
- try:
- self.run()
- except SystemExit:
- if __debug__:
- self._note("%s.__bootstrap(): raised SystemExit", self)
- except:
- if __debug__:
- self._note("%s.__bootstrap(): unhandled exception", self)
- s = _StringIO()
- _print_exc(file=s)
- _sys.stderr.write("Exception in thread %s:\n%s\n" %
- (self.getName(), s.getvalue()))
- else:
- if __debug__:
- self._note("%s.__bootstrap(): normal return", self)
- finally:
- self.__stop()
- self.__delete()
-
- def __stop(self):
- self.__block.acquire()
- self.__stopped = 1
- self.__block.notifyAll()
- self.__block.release()
-
- def __delete(self):
- _active_limbo_lock.acquire()
- del _active[_get_ident()]
- _active_limbo_lock.release()
-
- def join(self, timeout=None):
- assert self.__initialized, "Thread.__init__() not called"
- assert self.__started, "cannot join thread before it is started"
- assert self is not currentThread(), "cannot join current thread"
- if __debug__:
- if not self.__stopped:
- self._note("%s.join(): waiting until thread stops", self)
- self.__block.acquire()
- if timeout is None:
- while not self.__stopped:
- self.__block.wait()
- if __debug__:
- self._note("%s.join(): thread stopped", self)
- else:
- deadline = _time() + timeout
- while not self.__stopped:
- delay = deadline - _time()
- if delay <= 0:
- if __debug__:
- self._note("%s.join(): timed out", self)
- break
- self.__block.wait(delay)
- else:
- if __debug__:
- self._note("%s.join(): thread stopped", self)
- self.__block.release()
-
- def getName(self):
- assert self.__initialized, "Thread.__init__() not called"
- return self.__name
-
- def setName(self, name):
- assert self.__initialized, "Thread.__init__() not called"
- self.__name = str(name)
-
- def isAlive(self):
- assert self.__initialized, "Thread.__init__() not called"
- return self.__started and not self.__stopped
-
- def isDaemon(self):
- assert self.__initialized, "Thread.__init__() not called"
- return self.__daemonic
-
- def setDaemon(self, daemonic):
- assert self.__initialized, "Thread.__init__() not called"
- assert not self.__started, "cannot set daemon status of active thread"
- self.__daemonic = daemonic
-
-
-# Special thread class to represent the main thread
-# This is garbage collected through an exit handler
-
-class _MainThread(Thread):
-
- def __init__(self):
- Thread.__init__(self, name="MainThread")
- self._Thread__started = 1
- _active_limbo_lock.acquire()
- _active[_get_ident()] = self
- _active_limbo_lock.release()
- import atexit
- atexit.register(self.__exitfunc)
-
- def _set_daemon(self):
- return 0
-
- def __exitfunc(self):
- self._Thread__stop()
- t = _pickSomeNonDaemonThread()
- if t:
- if __debug__:
- self._note("%s: waiting for other threads", self)
- while t:
- t.join()
- t = _pickSomeNonDaemonThread()
- if __debug__:
- self._note("%s: exiting", self)
- self._Thread__delete()
-
-def _pickSomeNonDaemonThread():
- for t in enumerate():
- if not t.isDaemon() and t.isAlive():
- return t
- return None
-
-
-# Dummy thread class to represent threads not started here.
-# These aren't garbage collected when they die,
-# nor can they be waited for.
-# Their purpose is to return *something* from currentThread().
-# They are marked as daemon threads so we won't wait for them
-# when we exit (conform previous semantics).
-
-class _DummyThread(Thread):
-
- def __init__(self):
- Thread.__init__(self, name=_newname("Dummy-%d"))
- self._Thread__started = 1
- _active_limbo_lock.acquire()
- _active[_get_ident()] = self
- _active_limbo_lock.release()
-
- def _set_daemon(self):
- return 1
-
- def join(self):
- assert 0, "cannot join a dummy thread"
-
-
-# Global API functions
-
-def currentThread():
- try:
- return _active[_get_ident()]
- except KeyError:
- print "currentThread(): no current thread for", _get_ident()
- return _DummyThread()
-
-def activeCount():
- _active_limbo_lock.acquire()
- count = len(_active) + len(_limbo)
- _active_limbo_lock.release()
- return count
-
-def enumerate():
- _active_limbo_lock.acquire()
- active = _active.values() + _limbo.values()
- _active_limbo_lock.release()
- return active
-
-
-# Create the main thread object
-
-_MainThread()
-
-
-# Self-test code
-
-def _test():
-
- import random
-
- class BoundedQueue(_Verbose):
-
- def __init__(self, limit):
- _Verbose.__init__(self)
- self.mon = RLock()
- self.rc = Condition(self.mon)
- self.wc = Condition(self.mon)
- self.limit = limit
- self.queue = []
-
- def put(self, item):
- self.mon.acquire()
- while len(self.queue) >= self.limit:
- self._note("put(%s): queue full", item)
- self.wc.wait()
- self.queue.append(item)
- self._note("put(%s): appended, length now %d",
- item, len(self.queue))
- self.rc.notify()
- self.mon.release()
-
- def get(self):
- self.mon.acquire()
- while not self.queue:
- self._note("get(): queue empty")
- self.rc.wait()
- item = self.queue[0]
- del self.queue[0]
- self._note("get(): got %s, %d left", item, len(self.queue))
- self.wc.notify()
- self.mon.release()
- return item
-
- class ProducerThread(Thread):
-
- def __init__(self, queue, quota):
- Thread.__init__(self, name="Producer")
- self.queue = queue
- self.quota = quota
-
- def run(self):
- from random import random
- counter = 0
- while counter < self.quota:
- counter = counter + 1
- self.queue.put("%s.%d" % (self.getName(), counter))
- _sleep(random() * 0.00001)
-
-
- class ConsumerThread(Thread):
-
- def __init__(self, queue, count):
- Thread.__init__(self, name="Consumer")
- self.queue = queue
- self.count = count
-
- def run(self):
- while self.count > 0:
- item = self.queue.get()
- print item
- self.count = self.count - 1
-
- import time
-
- NP = 3
- QL = 4
- NI = 5
-
- Q = BoundedQueue(QL)
- P = []
- for i in range(NP):
- t = ProducerThread(Q, NI)
- t.setName("Producer-%d" % (i+1))
- P.append(t)
- C = ConsumerThread(Q, NI*NP)
- for t in P:
- t.start()
- _sleep(0.000001)
- C.start()
- for t in P:
- t.join()
- C.join()
-
-if __name__ == '__main__':
- _test()
diff --git a/Lib/dos-8x3/tokenize.py b/Lib/dos-8x3/tokenize.py
deleted file mode 100644
index 4883668..0000000
--- a/Lib/dos-8x3/tokenize.py
+++ /dev/null
@@ -1,161 +0,0 @@
-# Tests for the 'tokenize' module.
-# Large bits stolen from test_grammar.py.
-
-# Comments
-"#"
-#'
-#"
-#\
- #
- # abc
-'''#
-#'''
-
-x = 1 #
-
-# Balancing continuation
-
-a = (3, 4,
- 5, 6)
-y = [3, 4,
- 5]
-z = {'a':5,
- 'b':6}
-x = (len(`y`) + 5*x - a[
- 3 ]
- - x + len({
- }
- )
- )
-
-# Backslash means line continuation:
-x = 1 \
-+ 1
-
-# Backslash does not means continuation in comments :\
-x = 0
-
-# Ordinary integers
-0xff <> 255
-0377 <> 255
-2147483647 != 017777777777
--2147483647-1 != 020000000000
-037777777777 != -1
-0xffffffff != -1
-
-# Long integers
-x = 0L
-x = 0l
-x = 0xffffffffffffffffL
-x = 0xffffffffffffffffl
-x = 077777777777777777L
-x = 077777777777777777l
-x = 123456789012345678901234567890L
-x = 123456789012345678901234567890l
-
-# Floating-point numbers
-x = 3.14
-x = 314.
-x = 0.314
-# XXX x = 000.314
-x = .314
-x = 3e14
-x = 3E14
-x = 3e-14
-x = 3e+14
-x = 3.e14
-x = .3e14
-x = 3.1e4
-
-# String literals
-x = ''; y = "";
-x = '\''; y = "'";
-x = '"'; y = "\"";
-x = "doesn't \"shrink\" does it"
-y = 'doesn\'t "shrink" does it'
-x = "does \"shrink\" doesn't it"
-y = 'does "shrink" doesn\'t it'
-x = """
-The "quick"
-brown fox
-jumps over
-the 'lazy' dog.
-"""
-y = '\nThe "quick"\nbrown fox\njumps over\nthe \'lazy\' dog.\n'
-y = '''
-The "quick"
-brown fox
-jumps over
-the 'lazy' dog.
-''';
-y = "\n\
-The \"quick\"\n\
-brown fox\n\
-jumps over\n\
-the 'lazy' dog.\n\
-";
-y = '\n\
-The \"quick\"\n\
-brown fox\n\
-jumps over\n\
-the \'lazy\' dog.\n\
-';
-x = r'\\' + R'\\'
-x = r'\'' + ''
-y = r'''
-foo bar \\
-baz''' + R'''
-foo'''
-y = r"""foo
-bar \\ baz
-""" + R'''spam
-'''
-
-# Indentation
-if 1:
- x = 2
-if 1:
- x = 2
-if 1:
- while 0:
- if 0:
- x = 2
- x = 2
-if 0:
- if 2:
- while 0:
- if 1:
- x = 2
-
-# Operators
-
-def d22(a, b, c=1, d=2): pass
-def d01v(a=1, *rest, **rest): pass
-
-(x, y) <> ({'a':1}, {'b':2})
-
-# comparison
-if 1 < 1 > 1 == 1 >= 1 <= 1 <> 1 != 1 in 1 not in 1 is 1 is not 1: pass
-
-# binary
-x = 1 & 1
-x = 1 ^ 1
-x = 1 | 1
-
-# shift
-x = 1 << 1 >> 1
-
-# additive
-x = 1 - 1 + 1 - 1 + 1
-
-# multiplicative
-x = 1 / 1 * 1 % 1
-
-# unary
-x = ~1 ^ 1 & 1 | 1 & 1 ^ -1
-x = -1*1/1 + 1*1 - ---1*1
-
-# selector
-import sys, time
-x = sys.modules['time'].time()
-
diff --git a/Lib/dos-8x3/tracebac.py b/Lib/dos-8x3/tracebac.py
deleted file mode 100755
index b733598..0000000
--- a/Lib/dos-8x3/tracebac.py
+++ /dev/null
@@ -1,274 +0,0 @@
-"""Extract, format and print information about Python stack traces."""
-
-import linecache
-import string
-import sys
-import types
-
-def _print(file, str='', terminator='\n'):
- file.write(str+terminator)
-
-
-def print_list(extracted_list, file=None):
- """Print the list of tuples as returned by extract_tb() or
- extract_stack() as a formatted stack trace to the given file."""
- if not file:
- file = sys.stderr
- for filename, lineno, name, line in extracted_list:
- _print(file,
- ' File "%s", line %d, in %s' % (filename,lineno,name))
- if line:
- _print(file, ' %s' % string.strip(line))
-
-def format_list(extracted_list):
- """Given a list of tuples as returned by extract_tb() or
- extract_stack(), return a list of strings ready for printing.
- Each string in the resulting list corresponds to the item with
- the same index in the argument list. Each string ends in a
- newline; the strings may contain internal newlines as well, for
- those items whose source text line is not None."""
- list = []
- for filename, lineno, name, line in extracted_list:
- item = ' File "%s", line %d, in %s\n' % (filename,lineno,name)
- if line:
- item = item + ' %s\n' % string.strip(line)
- list.append(item)
- return list
-
-
-def print_tb(tb, limit=None, file=None):
- """Print up to 'limit' stack trace entries from the traceback 'tb'.
- If 'limit' is omitted or None, all entries are printed. If 'file' is
- omitted or None, the output goes to sys.stderr; otherwise 'file'
- should be an open file or file-like object with a write() method."""
- if not file:
- file = sys.stderr
- if limit is None:
- if hasattr(sys, 'tracebacklimit'):
- limit = sys.tracebacklimit
- n = 0
- while tb is not None and (limit is None or n < limit):
- f = tb.tb_frame
- lineno = tb_lineno(tb)
- co = f.f_code
- filename = co.co_filename
- name = co.co_name
- _print(file,
- ' File "%s", line %d, in %s' % (filename,lineno,name))
- line = linecache.getline(filename, lineno)
- if line: _print(file, ' ' + string.strip(line))
- tb = tb.tb_next
- n = n+1
-
-def format_tb(tb, limit = None):
- """A shorthand for 'format_list(extract_stack(f, limit))."""
- return format_list(extract_tb(tb, limit))
-
-def extract_tb(tb, limit = None):
- """Return a list of up to 'limit' pre-processed stack trace entries
- extracted from the traceback object 'traceback'. This is useful for
- alternate formatting of stack traces. If 'limit' is omitted or None,
- all entries are extracted. A pre-processed stack trace entry is a
- quadruple (filename, line number, function name, text) representing
- the information that is usually printed for a stack trace. The text
- is a string with leading and trailing whitespace stripped; if the
- source is not available it is None."""
- if limit is None:
- if hasattr(sys, 'tracebacklimit'):
- limit = sys.tracebacklimit
- list = []
- n = 0
- while tb is not None and (limit is None or n < limit):
- f = tb.tb_frame
- lineno = tb_lineno(tb)
- co = f.f_code
- filename = co.co_filename
- name = co.co_name
- line = linecache.getline(filename, lineno)
- if line: line = string.strip(line)
- else: line = None
- list.append((filename, lineno, name, line))
- tb = tb.tb_next
- n = n+1
- return list
-
-
-def print_exception(etype, value, tb, limit=None, file=None):
- """Print exception information and up to 'limit' stack trace entries
- from the traceback 'tb' to 'file'. This differs from print_tb() in
- the following ways: (1) if traceback is not None, it prints a header
- "Traceback (most recent call last):"; (2) it prints the exception type and
- value after the stack trace; (3) if type is SyntaxError and value has
- the appropriate format, it prints the line where the syntax error
- occurred with a caret on the next line indicating the approximate
- position of the error."""
- if not file:
- file = sys.stderr
- if tb:
- _print(file, 'Traceback (most recent call last):')
- print_tb(tb, limit, file)
- lines = format_exception_only(etype, value)
- for line in lines[:-1]:
- _print(file, line, ' ')
- _print(file, lines[-1], '')
-
-def format_exception(etype, value, tb, limit = None):
- """Format a stack trace and the exception information. The arguments
- have the same meaning as the corresponding arguments to
- print_exception(). The return value is a list of strings, each
- ending in a newline and some containing internal newlines. When
- these lines are concatenated and printed, exactly the same text is
- printed as does print_exception()."""
- if tb:
- list = ['Traceback (most recent call last):\n']
- list = list + format_tb(tb, limit)
- else:
- list = []
- list = list + format_exception_only(etype, value)
- return list
-
-def format_exception_only(etype, value):
- """Format the exception part of a traceback. The arguments are the
- exception type and value such as given by sys.last_type and
- sys.last_value. The return value is a list of strings, each ending
- in a newline. Normally, the list contains a single string;
- however, for SyntaxError exceptions, it contains several lines that
- (when printed) display detailed information about where the syntax
- error occurred. The message indicating which exception occurred is
- the always last string in the list."""
- list = []
- if type(etype) == types.ClassType:
- stype = etype.__name__
- else:
- stype = etype
- if value is None:
- list.append(str(stype) + '\n')
- else:
- if etype is SyntaxError:
- try:
- msg, (filename, lineno, offset, line) = value
- except:
- pass
- else:
- if not filename: filename = "<string>"
- list.append(' File "%s", line %d\n' %
- (filename, lineno))
- i = 0
- while i < len(line) and \
- line[i] in string.whitespace:
- i = i+1
- list.append(' %s\n' % string.strip(line))
- s = ' '
- for c in line[i:offset-1]:
- if c in string.whitespace:
- s = s + c
- else:
- s = s + ' '
- list.append('%s^\n' % s)
- value = msg
- list.append('%s: %s\n' % (str(stype), _some_str(value)))
- return list
-
-def _some_str(value):
- try:
- return str(value)
- except:
- return '<unprintable %s object>' % type(value).__name__
-
-
-def print_exc(limit=None, file=None):
- """This is a shorthand for 'print_exception(sys.exc_type,
- sys.exc_value, sys.exc_traceback, limit, file)'.
- (In fact, it uses sys.exc_info() to retrieve the same information
- in a thread-safe way.)"""
- if not file:
- file = sys.stderr
- try:
- etype, value, tb = sys.exc_info()
- print_exception(etype, value, tb, limit, file)
- finally:
- etype = value = tb = None
-
-def print_last(limit=None, file=None):
- """This is a shorthand for 'print_exception(sys.last_type,
- sys.last_value, sys.last_traceback, limit, file)'."""
- if not file:
- file = sys.stderr
- print_exception(sys.last_type, sys.last_value, sys.last_traceback,
- limit, file)
-
-
-def print_stack(f=None, limit=None, file=None):
- """This function prints a stack trace from its invocation point.
- The optional 'f' argument can be used to specify an alternate stack
- frame at which to start. The optional 'limit' and 'file' arguments
- have the same meaning as for print_exception()."""
- if f is None:
- try:
- raise ZeroDivisionError
- except ZeroDivisionError:
- f = sys.exc_info()[2].tb_frame.f_back
- print_list(extract_stack(f, limit), file)
-
-def format_stack(f=None, limit=None):
- """A shorthand for 'format_list(extract_stack(f, limit))'."""
- if f is None:
- try:
- raise ZeroDivisionError
- except ZeroDivisionError:
- f = sys.exc_info()[2].tb_frame.f_back
- return format_list(extract_stack(f, limit))
-
-def extract_stack(f=None, limit = None):
- """Extract the raw traceback from the current stack frame. The
- return value has the same format as for extract_tb(). The optional
- 'f' and 'limit' arguments have the same meaning as for print_stack().
- Each item in the list is a quadruple (filename, line number,
- function name, text), and the entries are in order from oldest
- to newest stack frame."""
- if f is None:
- try:
- raise ZeroDivisionError
- except ZeroDivisionError:
- f = sys.exc_info()[2].tb_frame.f_back
- if limit is None:
- if hasattr(sys, 'tracebacklimit'):
- limit = sys.tracebacklimit
- list = []
- n = 0
- while f is not None and (limit is None or n < limit):
- lineno = f.f_lineno # XXX Too bad if -O is used
- co = f.f_code
- filename = co.co_filename
- name = co.co_name
- line = linecache.getline(filename, lineno)
- if line: line = string.strip(line)
- else: line = None
- list.append((filename, lineno, name, line))
- f = f.f_back
- n = n+1
- list.reverse()
- return list
-
-def tb_lineno(tb):
- """Calculate the correct line number of the traceback given in tb
- (even 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.
-
- 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
- addr = 0
- for i in range(0, len(tab), 2):
- addr = addr + ord(tab[i])
- if addr > stopat:
- break
- line = line + ord(tab[i+1])
- return line
diff --git a/Lib/dos-8x3/userdict.py b/Lib/dos-8x3/userdict.py
deleted file mode 100755
index 9b6e73b..0000000
--- a/Lib/dos-8x3/userdict.py
+++ /dev/null
@@ -1,40 +0,0 @@
-"""A more or less complete user-defined wrapper around dictionary objects."""
-
-class UserDict:
- def __init__(self, dict=None):
- self.data = {}
- if dict is not None: self.update(dict)
- def __repr__(self): return repr(self.data)
- def __cmp__(self, dict):
- if isinstance(dict, UserDict):
- return cmp(self.data, dict.data)
- else:
- return cmp(self.data, dict)
- 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): self.data.clear()
- def copy(self):
- if self.__class__ is UserDict:
- return UserDict(self.data)
- 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, dict):
- if isinstance(dict, UserDict):
- self.data.update(dict.data)
- elif isinstance(dict, type(self.data)):
- self.data.update(dict)
- else:
- for k, v in dict.items():
- self.data[k] = v
- def get(self, key, failobj=None):
- return self.data.get(key, failobj)
- def setdefault(self, key, failobj=None):
- if not self.data.has_key(key):
- self.data[key] = failobj
- return self.data[key]
diff --git a/Lib/dos-8x3/userlist.py b/Lib/dos-8x3/userlist.py
deleted file mode 100755
index e79faea..0000000
--- a/Lib/dos-8x3/userlist.py
+++ /dev/null
@@ -1,79 +0,0 @@
-"""A more or less complete user-defined wrapper around list objects."""
-
-class UserList:
- def __init__(self, initlist=None):
- self.data = []
- if initlist is not None:
- # XXX should this accept an arbitrary sequence?
- if type(initlist) == type(self.data):
- self.data[:] = initlist
- elif isinstance(initlist, UserList):
- self.data[:] = initlist.data[:]
- else:
- self.data = list(initlist)
- def __repr__(self): return repr(self.data)
- def __cmp__(self, other):
- if isinstance(other, UserList):
- return cmp(self.data, other.data)
- else:
- return cmp(self.data, other)
- def __contains__(self, item): return item in self.data
- def __len__(self): return len(self.data)
- def __getitem__(self, i): return self.data[i]
- def __setitem__(self, i, item): self.data[i] = item
- def __delitem__(self, i): del self.data[i]
- def __getslice__(self, i, j):
- i = max(i, 0); j = max(j, 0)
- return self.__class__(self.data[i:j])
- def __setslice__(self, i, j, other):
- i = max(i, 0); j = max(j, 0)
- if isinstance(other, UserList):
- self.data[i:j] = other.data
- elif isinstance(other, type(self.data)):
- self.data[i:j] = other
- else:
- self.data[i:j] = list(other)
- def __delslice__(self, i, j):
- i = max(i, 0); j = max(j, 0)
- del self.data[i:j]
- def __add__(self, other):
- if isinstance(other, UserList):
- return self.__class__(self.data + other.data)
- elif isinstance(other, type(self.data)):
- return self.__class__(self.data + other)
- else:
- return self.__class__(self.data + list(other))
- def __radd__(self, other):
- if isinstance(other, UserList):
- return self.__class__(other.data + self.data)
- elif isinstance(other, type(self.data)):
- return self.__class__(other + self.data)
- else:
- return self.__class__(list(other) + self.data)
- def __iadd__(self, other):
- if isinstance(other, UserList):
- self.data += other.data
- elif isinstance(other, type(self.data)):
- self.data += other
- else:
- self.data += list(other)
- return self
- def __mul__(self, n):
- return self.__class__(self.data*n)
- __rmul__ = __mul__
- def __imul__(self, n):
- self.data *= n
- return self
- def append(self, item): self.data.append(item)
- def insert(self, i, item): self.data.insert(i, item)
- def pop(self, i=-1): return self.data.pop(i)
- def remove(self, item): self.data.remove(item)
- def count(self, item): return self.data.count(item)
- def index(self, item): return self.data.index(item)
- def reverse(self): self.data.reverse()
- def sort(self, *args): apply(self.data.sort, args)
- def extend(self, other):
- if isinstance(other, UserList):
- self.data.extend(other.data)
- else:
- self.data.extend(other)
diff --git a/Lib/dos-8x3/userstri.py b/Lib/dos-8x3/userstri.py
deleted file mode 100644
index ea3d515..0000000
--- a/Lib/dos-8x3/userstri.py
+++ /dev/null
@@ -1,171 +0,0 @@
-#!/usr/bin/env python
-## vim:ts=4:et:nowrap
-"""A user-defined wrapper around string objects
-
-Note: string objects have grown methods in Python 1.6
-This module requires Python 1.6 or later.
-"""
-from types import StringType, UnicodeType
-import sys
-
-class UserString:
- def __init__(self, seq):
- if isinstance(seq, StringType) or isinstance(seq, UnicodeType):
- self.data = seq
- elif isinstance(seq, UserString):
- self.data = seq.data[:]
- else:
- self.data = str(seq)
- def __str__(self): return str(self.data)
- def __repr__(self): return repr(self.data)
- def __int__(self): return int(self.data)
- def __long__(self): return long(self.data)
- def __float__(self): return float(self.data)
- def __complex__(self): return complex(self.data)
- def __hash__(self): return hash(self.data)
-
- def __cmp__(self, string):
- if isinstance(string, UserString):
- return cmp(self.data, string.data)
- else:
- return cmp(self.data, string)
- def __contains__(self, char):
- return char in self.data
-
- def __len__(self): return len(self.data)
- def __getitem__(self, index): return self.__class__(self.data[index])
- def __getslice__(self, start, end):
- start = max(start, 0); end = max(end, 0)
- return self.__class__(self.data[start:end])
-
- def __add__(self, other):
- if isinstance(other, UserString):
- return self.__class__(self.data + other.data)
- elif isinstance(other, StringType) or isinstance(other, UnicodeType):
- return self.__class__(self.data + other)
- else:
- return self.__class__(self.data + str(other))
- def __radd__(self, other):
- if isinstance(other, StringType) or isinstance(other, UnicodeType):
- return self.__class__(other + self.data)
- else:
- return self.__class__(str(other) + self.data)
- def __iadd__(self, other):
- if isinstance(other, UserString):
- self.data += other.data
- elif isinstance(other, StringType) or isinstance(other, UnicodeType):
- self.data += other
- else:
- self.data += str(other)
- return self
- def __mul__(self, n):
- return self.__class__(self.data*n)
- __rmul__ = __mul__
- def __imull__(self, n):
- self.data += n
- return self
-
- # the following methods are defined in alphabetical order:
- def capitalize(self): return self.__class__(self.data.capitalize())
- def center(self, width): return self.__class__(self.data.center(width))
- def count(self, sub, start=0, end=sys.maxint):
- return self.data.count(sub, start, end)
- def encode(self, encoding=None, errors=None): # XXX improve this?
- if encoding:
- if errors:
- return self.__class__(self.data.encode(encoding, errors))
- else:
- return self.__class__(self.data.encode(encoding))
- else:
- return self.__class__(self.data.encode())
- def endswith(self, suffix, start=0, end=sys.maxint):
- return self.data.endswith(suffix, start, end)
- def expandtabs(self, tabsize=8):
- return self.__class__(self.data.expandtabs(tabsize))
- def find(self, sub, start=0, end=sys.maxint):
- return self.data.find(sub, start, end)
- def index(self, sub, start=0, end=sys.maxint):
- return self.data.index(sub, start, end)
- def isalpha(self): return self.data.isalpha()
- def isalnum(self): return self.data.isalnum()
- def isdecimal(self): return self.data.isdecimal()
- def isdigit(self): return self.data.isdigit()
- def islower(self): return self.data.islower()
- def isnumeric(self): return self.data.isnumeric()
- def isspace(self): return self.data.isspace()
- def istitle(self): return self.data.istitle()
- def isupper(self): return self.data.isupper()
- def join(self, seq): return self.data.join(seq)
- def ljust(self, width): return self.__class__(self.data.ljust(width))
- def lower(self): return self.__class__(self.data.lower())
- def lstrip(self): return self.__class__(self.data.lstrip())
- def replace(self, old, new, maxsplit=-1):
- return self.__class__(self.data.replace(old, new, maxsplit))
- def rfind(self, sub, start=0, end=sys.maxint):
- return self.data.rfind(sub, start, end)
- def rindex(self, sub, start=0, end=sys.maxint):
- return self.data.rindex(sub, start, end)
- def rjust(self, width): return self.__class__(self.data.rjust(width))
- def rstrip(self): return self.__class__(self.data.rstrip())
- def split(self, sep=None, maxsplit=-1):
- return self.data.split(sep, maxsplit)
- def splitlines(self, keepends=0): return self.data.splitlines(keepends)
- def startswith(self, prefix, start=0, end=sys.maxint):
- return self.data.startswith(prefix, start, end)
- def strip(self): return self.__class__(self.data.strip())
- def swapcase(self): return self.__class__(self.data.swapcase())
- def title(self): return self.__class__(self.data.title())
- def translate(self, *args):
- return self.__class__(self.data.translate(*args))
- def upper(self): return self.__class__(self.data.upper())
-
-class MutableString(UserString):
- """mutable string objects
-
- Python strings are immutable objects. This has the advantage, that
- strings may be used as dictionary keys. If this property isn't needed
- and you insist on changing string values in place instead, you may cheat
- and use MutableString.
-
- But the purpose of this class is an educational one: to prevent
- people from inventing their own mutable string class derived
- from UserString and than forget thereby to remove (override) the
- __hash__ method inherited from ^UserString. This would lead to
- errors that would be very hard to track down.
-
- A faster and better solution is to rewrite your program using lists."""
- def __init__(self, string=""):
- self.data = string
- def __hash__(self):
- raise TypeError, "unhashable type (it is mutable)"
- def __setitem__(self, index, sub):
- if index < 0 or index >= len(self.data): raise IndexError
- self.data = self.data[:index] + sub + self.data[index+1:]
- def __delitem__(self, index):
- if index < 0 or index >= len(self.data): raise IndexError
- self.data = self.data[:index] + self.data[index+1:]
- def __setslice__(self, start, end, sub):
- start = max(start, 0); end = max(end, 0)
- if isinstance(sub, UserString):
- self.data = self.data[:start]+sub.data+self.data[end:]
- elif isinstance(sub, StringType) or isinstance(sub, UnicodeType):
- self.data = self.data[:start]+sub+self.data[end:]
- else:
- self.data = self.data[:start]+str(sub)+self.data[end:]
- def __delslice__(self, start, end):
- start = max(start, 0); end = max(end, 0)
- self.data = self.data[:start] + self.data[end:]
- def immutable(self):
- return UserString(self.data)
-
-if __name__ == "__main__":
- # execute the regression test to stdout, if called as a script:
- import os
- called_in_dir, called_as = os.path.split(sys.argv[0])
- called_in_dir = os.path.abspath(called_in_dir)
- called_as, py = os.path.splitext(called_as)
- sys.path.append(os.path.join(called_in_dir, 'test'))
- if '-q' in sys.argv:
- import test_support
- test_support.verbose = 0
- __import__('test_' + called_as.lower())
diff --git a/Lib/dos-8x3/webbrows.py b/Lib/dos-8x3/webbrows.py
deleted file mode 100644
index da70e3b..0000000
--- a/Lib/dos-8x3/webbrows.py
+++ /dev/null
@@ -1,225 +0,0 @@
-"""Remote-control interfaces to some browsers."""
-
-import os
-import sys
-
-
-PROCESS_CREATION_DELAY = 4
-
-
-class Error(Exception):
- pass
-
-
-_browsers = {}
-
-def register(name, klass, instance=None):
- """Register a browser connector and, optionally, connection."""
- _browsers[name.lower()] = [klass, instance]
-
-
-def get(name=None):
- """Retrieve a connection to a browser by type name, or the default
- browser."""
- name = name or DEFAULT_BROWSER
- try:
- L = _browsers[name.lower()]
- except KeyError:
- raise ValueError, "unknown browser type: " + `name`
- if L[1] is None:
- L[1] = L[0]()
- return L[1]
-
-
-# Please note: the following definition hides a builtin function.
-
-def open(url, new=0):
- get().open(url, new)
-
-
-def open_new(url):
- get().open_new(url)
-
-
-def _iscommand(cmd):
- """Return true if cmd can be found on the executable search path."""
- path = os.environ.get("PATH")
- if not path:
- return 0
- for d in path.split(os.pathsep):
- exe = os.path.join(d, cmd)
- if os.path.isfile(exe):
- return 1
- return 0
-
-
-class CommandLineBrowser:
- _browsers = []
- if os.environ.get("DISPLAY"):
- _browsers.extend([
- ("netscape", "netscape %s >/dev/null &"),
- ("mosaic", "mosaic %s >/dev/null &"),
- ])
- _browsers.extend([
- ("lynx", "lynx %s"),
- ("w3m", "w3m %s"),
- ])
-
- def open(self, url, new=0):
- for exe, cmd in self._browsers:
- if _iscommand(exe):
- os.system(cmd % url)
- return
- raise Error("could not locate runnable browser")
-
- def open_new(self, url):
- self.open(url)
-
-register("command-line", CommandLineBrowser)
-
-
-class Netscape:
- autoRaise = 1
-
- def _remote(self, action):
- raise_opt = ("-noraise", "-raise")[self.autoRaise]
- cmd = "netscape %s -remote '%s' >/dev/null 2>&1" % (raise_opt, action)
- rc = os.system(cmd)
- if rc:
- import time
- os.system("netscape -no-about-splash &")
- time.sleep(PROCESS_CREATION_DELAY)
- rc = os.system(cmd)
- return not rc
-
- def open(self, url, new=0):
- if new:
- self.open_new(url)
- else:
- self._remote("openURL(%s)" % url)
-
- def open_new(self, url):
- self._remote("openURL(%s, new-window)" % url)
-
-register("netscape", Netscape)
-
-
-class Konquerer:
- """Controller for the KDE File Manager (kfm, or Konquerer).
-
- See http://developer.kde.org/documentation/other/kfmclient.html
- for more information on the Konquerer remote-control interface.
-
- """
- def _remote(self, action):
- cmd = "kfmclient %s >/dev/null 2>&1" % action
- rc = os.system(cmd)
- if rc:
- import time
- os.system("kfm -d &")
- time.sleep(PROCESS_CREATION_DELAY)
- rc = os.system(cmd)
- return not rc
-
- def open(self, url, new=1):
- # XXX currently I know no way to prevent KFM from opening a new win.
- self.open_new(url)
-
- def open_new(self, url):
- self._remote("openURL %s" % url)
-
-register("kfm", Konquerer)
-
-
-class Grail:
- # There should be a way to maintain a connection to Grail, but the
- # Grail remote control protocol doesn't really allow that at this
- # point. It probably never will!
-
- def _find_grail_rc(self):
- import glob
- import pwd
- import socket
- import tempfile
- tempdir = os.path.join(tempfile.gettempdir(), ".grail-unix")
- user = pwd.getpwuid(_os.getuid())[0]
- filename = os.path.join(tempdir, user + "-*")
- maybes = glob.glob(filename)
- if not maybes:
- return None
- s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
- for fn in maybes:
- # need to PING each one until we find one that's live
- try:
- s.connect(fn)
- except socket.error:
- # no good; attempt to clean it out, but don't fail:
- try:
- os.unlink(fn)
- except IOError:
- pass
- else:
- return s
-
- def _remote(self, action):
- s = self._find_grail_rc()
- if not s:
- return 0
- s.send(action)
- s.close()
- return 1
-
- def open(self, url, new=0):
- if new:
- self.open_new(url)
- else:
- self._remote("LOAD " + url)
-
- def open_new(self, url):
- self._remote("LOADNEW " + url)
-
-register("grail", Grail)
-
-
-class WindowsDefault:
- def open(self, url, new=0):
- os.startfile(url)
-
- def open_new(self, url):
- self.open(url)
-
-
-DEFAULT_BROWSER = "command-line"
-
-if sys.platform[:3] == "win":
- del _browsers["kfm"]
- register("windows-default", WindowsDefault)
- DEFAULT_BROWSER = "windows-default"
-elif os.environ.get("DISPLAY"):
- if _iscommand("netscape"):
- DEFAULT_BROWSER = "netscape"
-
-# If the $BROWSER environment variable is set and true, let that be
-# the name of the browser to use:
-#
-DEFAULT_BROWSER = os.environ.get("BROWSER") or DEFAULT_BROWSER
-
-
-# Now try to support the MacOS world. This is the only supported
-# controller on that platform, so don't mess with the default!
-
-try:
- import ic
-except ImportError:
- pass
-else:
- class InternetConfig:
- def open(self, url, new=0):
- ic.launcurl(url)
-
- def open_new(self, url):
- self.open(url)
-
- _browsers.clear()
- register("internet-config", InternetConfig)
- DEFAULT_BROWSER = "internet-config"