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