+++ /dev/null
-"""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()
+++ /dev/null
-"""Object-oriented interface to the parser module.
-
-This module exports four 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 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.
-
-Common Methods
---------------
-
-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.
- """
- import parser # import internally to avoid
- _p = parser # 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. Line number information may
- optionally be present for any subset of the terminal tokens.
- """
- 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 list(self, line_info = 0):
- """Returns a fresh list representing the parse tree.
-
- line_info
- If true, includes line number information for terminal tokens in
- the output data structure,
- """
- return self._p.ast2list(self._ast, line_info)
-
- def tuple(self, line_info = 0):
- """Returns the tuple representing the parse tree.
-
- line_info
- If true, includes line number information for terminal tokens in
- the output data structure,
- """
- if self._tupl is None:
- self._tupl = self._p.ast2tuple(self._ast, line_info)
- 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
+++ /dev/null
-# 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()
+++ /dev/null
-# 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
+++ /dev/null
-import sys
-sys.modules['ni'] = sys.modules[__name__]
projects / python / commitdiff