--- /dev/null
+# Disassembler
+
+import sys
+import string
+
+def dis():
+ tb = sys.last_traceback
+ while tb.tb_next: tb = tb.tb_next
+ distb(tb)
+
+def distb(tb):
+ disassemble(tb.tb_frame.f_code, tb.tb_lasti)
+
+def disco(co):
+ disassemble(co, -1)
+
+def disassemble(co, lasti):
+ code = co.co_code
+ labels = findlabels(code)
+ n = len(code)
+ i = 0
+ while i < n:
+ c = code[i]
+ op = ord(c)
+ if op = SET_LINENO and i > 0: print # Extra blank line
+ if i = lasti: print '-->',
+ else: print ' ',
+ if i in labels: print '>>',
+ else: print ' ',
+ print string.rjust(`i`, 4),
+ print string.ljust(opname[op], 15),
+ i = i+1
+ if op >= HAVE_ARGUMENT:
+ oparg = ord(code[i]) + ord(code[i+1])*256
+ i = i+2
+ print string.rjust(`oparg`, 5),
+ if op in hasconst:
+ print '(' + `co.co_consts[oparg]` + ')',
+ elif op in hasname:
+ print '(' + co.co_names[oparg] + ')',
+ elif op in hasjrel:
+ print '(to ' + `i + oparg` + ')',
+ print
+
+def findlabels(code):
+ labels = []
+ n = len(code)
+ i = 0
+ while i < n:
+ c = code[i]
+ op = ord(c)
+ i = i+1
+ if op >= HAVE_ARGUMENT:
+ oparg = ord(code[i]) + ord(code[i+1])*256
+ i = i+2
+ label = -1
+ if op in hasjrel:
+ label = i+oparg
+ elif op in hasjabs:
+ label = oparg
+ if label >= 0:
+ if label not in labels:
+ labels.append(label)
+ return labels
+
+hasconst = []
+hasname = []
+hasjrel = []
+hasjabs = []
+
+opname = range(256)
+for op in opname: opname[op] = '<' + `op` + '>'
+
+def def_op(name, op):
+ opname[op] = name
+
+def name_op(name, op):
+ opname[op] = name
+ hasname.append(op)
+
+def jrel_op(name, op):
+ opname[op] = name
+ hasjrel.append(op)
+
+def jabs_op(name, op):
+ opname[op] = name
+ hasjabs.append(op)
+
+# Instruction opcodes for compiled code
+
+def_op('STOP_CODE', 0)
+def_op('POP_TOP', 1)
+def_op('ROT_TWO', 2)
+def_op('ROT_THREE', 3)
+def_op('DUP_TOP', 4)
+
+def_op('UNARY_POSITIVE', 10)
+def_op('UNARY_NEGATIVE', 11)
+def_op('UNARY_NOT', 12)
+def_op('UNARY_CONVERT', 13)
+def_op('UNARY_CALL', 14)
+
+def_op('BINARY_MULTIPLY', 20)
+def_op('BINARY_DIVIDE', 21)
+def_op('BINARY_MODULO', 22)
+def_op('BINARY_ADD', 23)
+def_op('BINARY_SUBTRACT', 24)
+def_op('BINARY_SUBSCR', 25)
+def_op('BINARY_CALL', 26)
+
+def_op('SLICE+0', 30)
+def_op('SLICE+1', 31)
+def_op('SLICE+2', 32)
+def_op('SLICE+3', 33)
+
+def_op('STORE_SLICE+0', 40)
+def_op('STORE_SLICE+1', 41)
+def_op('STORE_SLICE+2', 42)
+def_op('STORE_SLICE+3', 43)
+
+def_op('DELETE_SLICE+0', 50)
+def_op('DELETE_SLICE+1', 51)
+def_op('DELETE_SLICE+2', 52)
+def_op('DELETE_SLICE+3', 53)
+
+def_op('STORE_SUBSCR', 60)
+def_op('DELETE_SUBSCR', 61)
+
+def_op('PRINT_EXPR', 70)
+def_op('PRINT_ITEM', 71)
+def_op('PRINT_NEWLINE', 72)
+
+def_op('BREAK_LOOP', 80)
+def_op('RAISE_EXCEPTION', 81)
+def_op('LOAD_LOCALS', 82)
+def_op('RETURN_VALUE', 83)
+def_op('REQUIRE_ARGS', 84)
+def_op('REFUSE_ARGS', 85)
+def_op('BUILD_FUNCTION', 86)
+def_op('POP_BLOCK', 87)
+def_op('END_FINALLY', 88)
+def_op('BUILD_CLASS', 89)
+
+HAVE_ARGUMENT = 90 # Opcodes from here have an argument:
+
+name_op('STORE_NAME', 90) # Index in name list
+name_op('DELETE_NAME', 91) # ""
+def_op('UNPACK_TUPLE', 92) # Number of tuple items
+def_op('UNPACK_LIST', 93) # Number of list items
+# unused: 94
+name_op('STORE_ATTR', 95) # Index in name list
+name_op('DELETE_ATTR', 96) # ""
+
+def_op('LOAD_CONST', 100) # Index in const list
+hasconst.append(100)
+name_op('LOAD_NAME', 101) # Index in name list
+def_op('BUILD_TUPLE', 102) # Number of tuple items
+def_op('BUILD_LIST', 103) # Number of list items
+def_op('BUILD_MAP', 104) # Always zero for now
+name_op('LOAD_ATTR', 105) # Index in name list
+def_op('COMPARE_OP', 106) # Comparison operator
+name_op('IMPORT_NAME', 107) # Index in name list
+name_op('IMPORT_FROM', 108) # Index in name list
+
+jrel_op('JUMP_FORWARD', 110) # Number of bytes to skip
+jrel_op('JUMP_IF_FALSE', 111) # ""
+jrel_op('JUMP_IF_TRUE', 112) # ""
+jabs_op('JUMP_ABSOLUTE', 113) # Target byte offset from beginning of code
+jrel_op('FOR_LOOP', 114) # Number of bytes to skip
+
+jrel_op('SETUP_LOOP', 120) # Distance to target address
+jrel_op('SETUP_EXCEPT', 121) # ""
+jrel_op('SETUP_FINALLY', 122) # ""
+
+def_op('SET_LINENO', 127) # Current line number
+SET_LINENO = 127
--- /dev/null
+# 'grep'
+
+import regexp
+import string
+
+def grep(expr, filename):
+ prog = regexp.compile(expr)
+ fp = open(filename, 'r')
+ lineno = 0
+ while 1:
+ line = fp.readline()
+ if not line: break
+ lineno = lineno + 1
+ res = prog.exec(line)
+ if res:
+ #print res
+ start, end = res[0]
+ if line[-1:] = '\n': line = line[:-1]
+ prefix = string.rjust(`lineno`, 3) + ': '
+ print prefix + line
+ if 0:
+ line = line[:start]
+ if '\t' not in line:
+ prefix = ' ' * (len(prefix) + start)
+ else:
+ prefix = ' ' * len(prefix)
+ for c in line:
+ if c <> '\t': c = ' '
+ prefix = prefix + c
+ if start = end: prefix = prefix + '\\'
+ else: prefix = prefix + '^'*(end-start)
+ print prefix
--- /dev/null
+# 'grep'
+
+import regexp
+import string
+
+def grep(expr, filename):
+ prog = regexp.compile(expr)
+ fp = open(filename, 'r')
+ lineno = 0
+ while 1:
+ line = fp.readline()
+ if not line: break
+ lineno = lineno + 1
+ res = prog.exec(line)
+ if res:
+ #print res
+ start, end = res[0]
+ if line[-1:] = '\n': line = line[:-1]
+ prefix = string.rjust(`lineno`, 3) + ': '
+ print prefix + line
+ if 0:
+ line = line[:start]
+ if '\t' not in line:
+ prefix = ' ' * (len(prefix) + start)
+ else:
+ prefix = ' ' * len(prefix)
+ for c in line:
+ if c <> '\t': c = ' '
+ prefix = prefix + c
+ if start = end: prefix = prefix + '\\'
+ else: prefix = prefix + '^'*(end-start)
+ print prefix
--- /dev/null
+# Module 'packmail' -- create a shell script out of some files.
+
+import mac
+import macpath
+from stat import ST_MTIME
+
+# Pack one file
+def pack(outfp, file, name):
+ fp = open(file, 'r')
+ outfp.write('sed "s/^X//" >' + name + ' <<"!"\n')
+ while 1:
+ line = fp.readline()
+ if not line: break
+ if line[-1:] <> '\n':
+ line = line + '\n'
+ outfp.write('X' + line)
+ outfp.write('!\n')
+
+# Pack some files from a directory
+def packsome(outfp, dirname, names):
+ for name in names:
+ print name
+ file = macpath.cat(dirname, name)
+ pack(outfp, file, name)
+
+# Pack all files from a directory
+def packall(outfp, dirname):
+ names = mac.listdir(dirname)
+ names.sort()
+ packsome(outfp, dirname, names)
+
+# Pack all files from a directory that are not older than a give one
+def packnotolder(outfp, dirname, oldest):
+ names = mac.listdir(dirname)
+ oldest = macpath.cat(dirname, oldest)
+ st = mac.stat(oldest)
+ mtime = st[ST_MTIME]
+ todo = []
+ for name in names:
+ print name, '...',
+ st = mac.stat(macpath.cat(dirname, name))
+ if st[ST_MTIME] >= mtime:
+ print 'Yes.'
+ todo.append(name)
+ else:
+ print 'No.'
+ todo.sort()
+ packsome(outfp, dirname, todo)
--- /dev/null
+# Print tracebacks, with a dump of local variables.
+# Also an interactive stack trace browser.
+
+import sys
+try:
+ import mac
+ os = mac
+except NameError:
+ import posix
+ os = posix
+from stat import *
+import string
+
+def br(): browser(sys.last_traceback)
+
+def tb(): printtb(sys.last_traceback)
+
+def browser(tb):
+ if not tb:
+ print 'No traceback.'
+ return
+ tblist = []
+ while tb:
+ tblist.append(tb)
+ tb = tb.tb_next
+ ptr = len(tblist)-1
+ tb = tblist[ptr]
+ while 1:
+ if tb <> tblist[ptr]:
+ tb = tblist[ptr]
+ print `ptr` + ':',
+ printtbheader(tb)
+ try:
+ line = raw_input('TB: ')
+ except KeyboardInterrupt:
+ print '\n[Interrupted]'
+ break
+ except EOFError:
+ print '\n[EOF]'
+ break
+ cmd = string.strip(line)
+ if cmd:
+ if cmd = 'quit':
+ break
+ elif cmd = 'list':
+ browserlist(tb)
+ elif cmd = 'up':
+ if ptr-1 >= 0: ptr = ptr-1
+ else: print 'Bottom of stack.'
+ elif cmd = 'down':
+ if ptr+1 < len(tblist): ptr = ptr+1
+ else: print 'Top of stack.'
+ elif cmd = 'locals':
+ printsymbols(tb.tb_frame.f_locals)
+ elif cmd = 'globals':
+ printsymbols(tb.tb_frame.f_globals)
+ elif cmd in ('?', 'help'):
+ browserhelp()
+ else:
+ browserexec(tb, cmd)
+
+def browserlist(tb):
+ filename = tb.tb_frame.f_code.co_filename
+ lineno = tb.tb_lineno
+ last = lineno
+ first = max(1, last-10)
+ for i in range(first, last+1):
+ if i = lineno: prefix = '***' + string.rjust(`i`, 4) + ':'
+ else: prefix = string.rjust(`i`, 7) + ':'
+ line = readfileline(filename, i)
+ if line[-1:] = '\n': line = line[:-1]
+ print prefix + line
+
+def browserexec(tb, cmd):
+ locals = tb.tb_frame.f_locals
+ globals = tb.tb_frame.f_globals
+ try:
+ exec(cmd+'\n', globals, locals)
+ except:
+ print '*** Exception:',
+ print sys.exc_type,
+ if sys.exc_value <> None:
+ print ':', sys.exc_value,
+ print
+ print 'Type help to get help.'
+
+def browserhelp():
+ print
+ print ' This is the traceback browser. Commands are:'
+ print ' up : move one level up in the call stack'
+ print ' down : move one level down in the call stack'
+ print ' locals : print all local variables at this level'
+ print ' globals : print all global variables at this level'
+ print ' list : list source code around the failure'
+ print ' help : print help (what you are reading now)'
+ print ' quit : back to command interpreter'
+ print ' Typing any other 1-line statement will execute it'
+ print ' using the current level\'s symbol tables'
+ print
+
+def printtb(tb):
+ while tb:
+ print1tb(tb)
+ tb = tb.tb_next
+
+def print1tb(tb):
+ printtbheader(tb)
+ if tb.tb_frame.f_locals is not tb.tb_frame.f_globals:
+ printsymbols(tb.tb_frame.f_locals)
+
+def printtbheader(tb):
+ filename = tb.tb_frame.f_code.co_filename
+ lineno = tb.tb_lineno
+ info = '"' + filename + '"(' + `lineno` + ')'
+ line = readfileline(filename, lineno)
+ if line:
+ info = info + ': ' + string.strip(line)
+ print info
+
+def printsymbols(d):
+ keys = d.keys()
+ keys.sort()
+ for name in keys:
+ print ' ' + string.ljust(name, 12) + ':',
+ printobject(d[name], 4)
+ print
+
+def printobject(v, maxlevel):
+ if v = None:
+ print 'None',
+ elif type(v) in (type(0), type(0.0)):
+ print v,
+ elif type(v) = type(''):
+ if len(v) > 20:
+ print `v[:17] + '...'`,
+ else:
+ print `v`,
+ elif type(v) = type(()):
+ print '(',
+ printlist(v, maxlevel)
+ print ')',
+ elif type(v) = type([]):
+ print '[',
+ printlist(v, maxlevel)
+ print ']',
+ elif type(v) = type({}):
+ print '{',
+ printdict(v, maxlevel)
+ print '}',
+ else:
+ print v,
+
+def printlist(v, maxlevel):
+ n = len(v)
+ if n = 0: return
+ if maxlevel <= 0:
+ print '...',
+ return
+ for i in range(min(6, n)):
+ printobject(v[i], maxlevel-1)
+ if i+1 < n: print ',',
+ if n > 6: print '...',
+
+def printdict(v, maxlevel):
+ keys = v.keys()
+ n = len(keys)
+ if n = 0: return
+ if maxlevel <= 0:
+ print '...',
+ return
+ keys.sort()
+ for i in range(min(6, n)):
+ key = keys[i]
+ print `key` + ':',
+ printobject(v[key], maxlevel-1)
+ if i+1 < n: print ',',
+ if n > 6: print '...',
+
+_filecache = {}
+
+def readfileline(filename, lineno):
+ try:
+ stat = os.stat(filename)
+ except os.error, msg:
+ print 'Cannot stat', filename, '--', msg
+ return ''
+ cache_ok = 0
+ if _filecache.has_key(filename):
+ cached_stat, lines = _filecache[filename]
+ if stat[ST_SIZE] = cached_stat[ST_SIZE] and \
+ stat[ST_MTIME] = cached_stat[ST_MTIME]:
+ cache_ok = 1
+ else:
+ print 'Stale cache entry for', filename
+ del _filecache[filename]
+ if not cache_ok:
+ lines = readfilelines(filename)
+ if not lines:
+ return ''
+ _filecache[filename] = stat, lines
+ if 0 <= lineno-1 < len(lines):
+ return lines[lineno-1]
+ else:
+ print 'Line number out of range, last line is', len(lines)
+ return ''
+
+def readfilelines(filename):
+ try:
+ fp = open(filename, 'r')
+ except:
+ print 'Cannot open', filename
+ return []
+ lines = []
+ while 1:
+ line = fp.readline()
+ if not line: break
+ lines.append(line)
+ if not lines:
+ print 'Empty file', filename
+ return lines
--- /dev/null
+# module 'macpath'
+
+import mac
+
+import string
+
+from stat import *
+
+def isabs(s):
+ return ':' in s and s[0] <> ':'
+
+def cat(s, t):
+ if (not s) or isabs(t): return t
+ if t[:1] = ':': t = t[1:]
+ if ':' not in s:
+ s = ':' + s
+ if s[-1:] <> ':':
+ s = s + ':'
+ return s + t
+
+norm_error = 'path cannot be normalized'
+
+def norm(s):
+ if ':' not in s:
+ return ':' + s
+ f = string.splitfields(s, ':')
+ pre = []
+ post = []
+ if not f[0]:
+ pre = f[:1]
+ f = f[1:]
+ if not f[len(f)-1]:
+ post = f[-1:]
+ f = f[:-1]
+ res = []
+ for seg in f:
+ if seg:
+ res.append(seg)
+ else:
+ if not res: raise norm_error # starts with '::'
+ del res[len(res)-1]
+ if not (pre or res):
+ raise norm_error # starts with 'vol::'
+ if pre: res = pre + res
+ if post: res = res + post
+ s = res[0]
+ for seg in res[1:]:
+ s = s + ':' + seg
+ return s
+
+def isdir(s):
+ try:
+ st = mac.stat(s)
+ except mac.error:
+ return 0
+ return S_ISDIR(st[ST_MODE])
+
+def isfile(s):
+ try:
+ st = mac.stat(s)
+ except mac.error:
+ return 0
+ return S_ISREG(st[ST_MODE])
+
+def exists(s):
+ try:
+ st = mac.stat(s)
+ except mac.error:
+ return 0
+ return 1
--- /dev/null
+# Module 'packmail' -- create a shell script out of some files.
+
+import mac
+import macpath
+from stat import ST_MTIME
+
+# Pack one file
+def pack(outfp, file, name):
+ fp = open(file, 'r')
+ outfp.write('sed "s/^X//" >' + name + ' <<"!"\n')
+ while 1:
+ line = fp.readline()
+ if not line: break
+ if line[-1:] <> '\n':
+ line = line + '\n'
+ outfp.write('X' + line)
+ outfp.write('!\n')
+
+# Pack some files from a directory
+def packsome(outfp, dirname, names):
+ for name in names:
+ print name
+ file = macpath.cat(dirname, name)
+ pack(outfp, file, name)
+
+# Pack all files from a directory
+def packall(outfp, dirname):
+ names = mac.listdir(dirname)
+ names.sort()
+ packsome(outfp, dirname, names)
+
+# Pack all files from a directory that are not older than a give one
+def packnotolder(outfp, dirname, oldest):
+ names = mac.listdir(dirname)
+ oldest = macpath.cat(dirname, oldest)
+ st = mac.stat(oldest)
+ mtime = st[ST_MTIME]
+ todo = []
+ for name in names:
+ print name, '...',
+ st = mac.stat(macpath.cat(dirname, name))
+ if st[ST_MTIME] >= mtime:
+ print 'Yes.'
+ todo.append(name)
+ else:
+ print 'No.'
+ todo.sort()
+ packsome(outfp, dirname, todo)
--- /dev/null
+# Module 'sunaudio' -- interpret sun audio headers
+
+import audio
+
+MAGIC = '.snd'
+
+error = 'sunaudio sound header conversion error'
+
+
+# convert a 4-char value to integer
+
+def c2i(data):
+ if type(data) <> type('') or len(data) <> 4:
+ raise error, 'c2i: bad arg (not string[4])'
+ bytes = audio.chr2num(data)
+ for i in (1, 2, 3):
+ if bytes[i] < 0:
+ bytes[i] = bytes[i] + 256
+ return ((bytes[0]*256 + bytes[1])*256 + bytes[2])*256 + bytes[3]
+
+
+# read a sound header from an open file
+
+def gethdr(fp):
+ if fp.read(4) <> MAGIC:
+ raise error, 'gethdr: bad magic word'
+ hdr_size = c2i(fp.read(4))
+ data_size = c2i(fp.read(4))
+ encoding = c2i(fp.read(4))
+ sample_rate = c2i(fp.read(4))
+ channels = c2i(fp.read(4))
+ excess = hdr_size - 24
+ if excess < 0:
+ raise error, 'gethdr: bad hdr_size'
+ if excess > 0:
+ info = fp.read(excess)
+ else:
+ info = ''
+ return (data_size, encoding, sample_rate, channels, info)
+
+
+# read and print the sound header of a named file
+
+def printhdr(file):
+ hdr = gethdr(open(file, 'r'))
+ data_size, encoding, sample_rate, channels, info = hdr
+ while info[-1:] = '\0':
+ info = info[:-1]
+ print 'File name: ', file
+ print 'Data size: ', data_size
+ print 'Encoding: ', encoding
+ print 'Sample rate:', sample_rate
+ print 'Channels: ', channels
+ print 'Info: ', `info`
--- /dev/null
+# Print tracebacks, with a dump of local variables.
+# Also an interactive stack trace browser.
+
+import sys
+try:
+ import mac
+ os = mac
+except NameError:
+ import posix
+ os = posix
+from stat import *
+import string
+
+def br(): browser(sys.last_traceback)
+
+def tb(): printtb(sys.last_traceback)
+
+def browser(tb):
+ if not tb:
+ print 'No traceback.'
+ return
+ tblist = []
+ while tb:
+ tblist.append(tb)
+ tb = tb.tb_next
+ ptr = len(tblist)-1
+ tb = tblist[ptr]
+ while 1:
+ if tb <> tblist[ptr]:
+ tb = tblist[ptr]
+ print `ptr` + ':',
+ printtbheader(tb)
+ try:
+ line = raw_input('TB: ')
+ except KeyboardInterrupt:
+ print '\n[Interrupted]'
+ break
+ except EOFError:
+ print '\n[EOF]'
+ break
+ cmd = string.strip(line)
+ if cmd:
+ if cmd = 'quit':
+ break
+ elif cmd = 'list':
+ browserlist(tb)
+ elif cmd = 'up':
+ if ptr-1 >= 0: ptr = ptr-1
+ else: print 'Bottom of stack.'
+ elif cmd = 'down':
+ if ptr+1 < len(tblist): ptr = ptr+1
+ else: print 'Top of stack.'
+ elif cmd = 'locals':
+ printsymbols(tb.tb_frame.f_locals)
+ elif cmd = 'globals':
+ printsymbols(tb.tb_frame.f_globals)
+ elif cmd in ('?', 'help'):
+ browserhelp()
+ else:
+ browserexec(tb, cmd)
+
+def browserlist(tb):
+ filename = tb.tb_frame.f_code.co_filename
+ lineno = tb.tb_lineno
+ last = lineno
+ first = max(1, last-10)
+ for i in range(first, last+1):
+ if i = lineno: prefix = '***' + string.rjust(`i`, 4) + ':'
+ else: prefix = string.rjust(`i`, 7) + ':'
+ line = readfileline(filename, i)
+ if line[-1:] = '\n': line = line[:-1]
+ print prefix + line
+
+def browserexec(tb, cmd):
+ locals = tb.tb_frame.f_locals
+ globals = tb.tb_frame.f_globals
+ try:
+ exec(cmd+'\n', globals, locals)
+ except:
+ print '*** Exception:',
+ print sys.exc_type,
+ if sys.exc_value <> None:
+ print ':', sys.exc_value,
+ print
+ print 'Type help to get help.'
+
+def browserhelp():
+ print
+ print ' This is the traceback browser. Commands are:'
+ print ' up : move one level up in the call stack'
+ print ' down : move one level down in the call stack'
+ print ' locals : print all local variables at this level'
+ print ' globals : print all global variables at this level'
+ print ' list : list source code around the failure'
+ print ' help : print help (what you are reading now)'
+ print ' quit : back to command interpreter'
+ print ' Typing any other 1-line statement will execute it'
+ print ' using the current level\'s symbol tables'
+ print
+
+def printtb(tb):
+ while tb:
+ print1tb(tb)
+ tb = tb.tb_next
+
+def print1tb(tb):
+ printtbheader(tb)
+ if tb.tb_frame.f_locals is not tb.tb_frame.f_globals:
+ printsymbols(tb.tb_frame.f_locals)
+
+def printtbheader(tb):
+ filename = tb.tb_frame.f_code.co_filename
+ lineno = tb.tb_lineno
+ info = '"' + filename + '"(' + `lineno` + ')'
+ line = readfileline(filename, lineno)
+ if line:
+ info = info + ': ' + string.strip(line)
+ print info
+
+def printsymbols(d):
+ keys = d.keys()
+ keys.sort()
+ for name in keys:
+ print ' ' + string.ljust(name, 12) + ':',
+ printobject(d[name], 4)
+ print
+
+def printobject(v, maxlevel):
+ if v = None:
+ print 'None',
+ elif type(v) in (type(0), type(0.0)):
+ print v,
+ elif type(v) = type(''):
+ if len(v) > 20:
+ print `v[:17] + '...'`,
+ else:
+ print `v`,
+ elif type(v) = type(()):
+ print '(',
+ printlist(v, maxlevel)
+ print ')',
+ elif type(v) = type([]):
+ print '[',
+ printlist(v, maxlevel)
+ print ']',
+ elif type(v) = type({}):
+ print '{',
+ printdict(v, maxlevel)
+ print '}',
+ else:
+ print v,
+
+def printlist(v, maxlevel):
+ n = len(v)
+ if n = 0: return
+ if maxlevel <= 0:
+ print '...',
+ return
+ for i in range(min(6, n)):
+ printobject(v[i], maxlevel-1)
+ if i+1 < n: print ',',
+ if n > 6: print '...',
+
+def printdict(v, maxlevel):
+ keys = v.keys()
+ n = len(keys)
+ if n = 0: return
+ if maxlevel <= 0:
+ print '...',
+ return
+ keys.sort()
+ for i in range(min(6, n)):
+ key = keys[i]
+ print `key` + ':',
+ printobject(v[key], maxlevel-1)
+ if i+1 < n: print ',',
+ if n > 6: print '...',
+
+_filecache = {}
+
+def readfileline(filename, lineno):
+ try:
+ stat = os.stat(filename)
+ except os.error, msg:
+ print 'Cannot stat', filename, '--', msg
+ return ''
+ cache_ok = 0
+ if _filecache.has_key(filename):
+ cached_stat, lines = _filecache[filename]
+ if stat[ST_SIZE] = cached_stat[ST_SIZE] and \
+ stat[ST_MTIME] = cached_stat[ST_MTIME]:
+ cache_ok = 1
+ else:
+ print 'Stale cache entry for', filename
+ del _filecache[filename]
+ if not cache_ok:
+ lines = readfilelines(filename)
+ if not lines:
+ return ''
+ _filecache[filename] = stat, lines
+ if 0 <= lineno-1 < len(lines):
+ return lines[lineno-1]
+ else:
+ print 'Line number out of range, last line is', len(lines)
+ return ''
+
+def readfilelines(filename):
+ try:
+ fp = open(filename, 'r')
+ except:
+ print 'Cannot open', filename
+ return []
+ lines = []
+ while 1:
+ line = fp.readline()
+ if not line: break
+ lines.append(line)
+ if not lines:
+ print 'Empty file', filename
+ return lines
--- /dev/null
+# Module 'testall'
+#
+# Python test set, should exercise:
+# - all lexical and grammatical constructs
+# - all opcodes from "opcode.h"
+# - all operations on all object types
+# - all builtin functions
+# Ideally also:
+# - all possible exception situations (Thank God we've got 'try')
+# - all boundary cases
+
+
+TestFailed = 'testall -- test failed' # Exception
+
+
+#########################################################
+# Part 1. Test all lexical and grammatical constructs.
+# This just tests whether the parser accepts them all.
+#########################################################
+
+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 Number formats'
+
+if 0xff <> 255: raise TestFailed, 'hex number'
+if 0377 <> 255: raise TestFailed, 'octal number'
+x = 3.14
+x = 0.314
+x = 3e14
+x = 3E14
+x = 3e-14
+
+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: '(' [fplist] ')'
+### fplist: fpdef (',' fpdef)*
+### fpdef: NAME | '(' fplist ')'
+def f1(): pass
+def f2(one_argument): pass
+def f3(two, arguments): pass
+def f4(two, (compound, (arguments))): pass
+
+### stmt: simple_stmt | compound_stmt
+### simple_stmt: expr_stmt | print_stmt | pass_stmt | del_stmt | flow_stmt | import_stmt
+# Tested below
+
+print 'expr_stmt' # (exprlist '=')* exprlist NEWLINE
+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] NEWLINE
+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 NEWLINE
+del abc
+del x, y, (z, xyz)
+
+print 'pass_stmt' # 'pass' NEWLINE
+pass
+
+print 'flow_stmt' # break_stmt | return_stmt | raise_stmt
+# Tested below
+
+print 'break_stmt' # 'break' NEWLINE
+while 1: break
+
+print 'return_stmt' # 'return' [testlist] NEWLINE
+def g1(): return
+def g2(): return 1
+g1()
+x = g2()
+
+print 'raise_stmt' # 'raise' expr [',' expr] NEWLINE
+try: raise RuntimeError, 'just testing'
+except RuntimeError: pass
+try: raise KeyboardInterrupt
+except KeyboardInterrupt: pass
+
+print 'import_stmt' # 'import' NAME (',' NAME)* NEWLINE | 'from' NAME 'import' ('*' | NAME (',' NAME)*) NEWLINE
+[1]
+import sys
+[2]
+import time, math
+[3]
+from time import sleep
+[4]
+from math import *
+[5]
+from sys import modules, ps1, ps2
+[6]
+
+### 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]
+[1]
+for i in 1, 2, 3: pass
+[2]
+for i, j, k in (): pass
+else: pass
+[3]
+
+print 'try_stmt' # 'try' ':' suite (except_clause ':' suite)* ['finally' ':' suite]
+### except_clause: 'except' [expr [',' expr]]
+try: pass
+try: 1/0
+except RuntimeError: pass
+try: 1/0
+except EOFError: pass
+except TypeError, msg: pass
+except RuntimeError, msg: pass
+except: pass
+try: pass
+finally: pass
+try: 1/0
+except: 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
+### comparison: expr (comp_op expr)*
+### comp_op: '<'|'>'|'='|'>' '='|'<' '='|'<' '>'|'in'|'not' 'in'|'is'|'is' 'not'
+if 1: pass
+if 1 = 1: pass
+if 1 < 1 > 1 = 1 >= 1 <= 1 <> 1 in 1 not in 1 is 1 is not 1: pass
+if not 1 = 1 = 1: pass
+if not 1 = 1 and 1 and 1: pass
+if 1 and 1 or 1 and 1 and 1 or not 1 = 1 = 1 and 1: pass
+
+print 'expr' # term (('+'|'-') term)*
+x = 1
+x = 1 + 1
+x = 1 - 1 - 1
+x = 1 - 1 + 1 - 1 + 1
+
+print 'term' # factor (('*'|'/'|'%') factor)*
+x = 1 * 1
+x = 1 / 1
+x = 1 % 1
+x = 1 / 1 * 1 % 1
+
+print 'factor' # ('+'|'-') factor | atom trailer*
+### trailer: '(' [testlist] ')' | '[' subscript ']' | '.' NAME
+### subscript: expr | [expr] ':' [expr]
+x = +1
+x = -1
+x = 1
+c = sys.ps1[0]
+x = time.time()
+x = sys.modules['time'].time()
+a = '01234'
+c = a[0]
+c = a[0:5]
+c = a[:5]
+c = a[0:]
+c = a[:]
+c = a[-5:]
+c = a[:-1]
+c = a[-4:-3]
+
+print 'atom' # '(' [testlist] ')' | '[' [testlist] ']' | '{' '}' | '`' testlist '`' | NAME | NUMBER | STRING
+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 = `x`
+x = x
+x = 'x'
+x = 123
+
+### exprlist: expr (',' expr)* [',']
+### testlist: test (',' test)* [',']
+# These have been exercised enough above
+
+print 'classdef' # 'class' NAME parameters ['=' baselist] ':' suite
+### baselist: atom arguments (',' atom arguments)*
+### arguments: '(' [testlist] ')'
+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
+
+
+#########################################################
+# Part 2. Test all opcodes from "opcode.h"
+#########################################################
+
+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 RuntimeError: pass
+ except TypeError: pass
+ finally: pass
+ try: pass
+ except: pass
+ try: pass
+ finally: pass
+ n = n+i
+if n <> 90:
+ raise TestFailed, 'try inside for'
+
+
+#########################################################
+# Part 3. Test all operations on all object types
+#########################################################
+
+print '3. Object types'
+print 'XXX Not yet implemented'
+
+
+#########################################################
+# Part 4. Test all built-in functions
+#########################################################
+
+print '4. Built-in functions'
+
+print 'abs'
+if abs(0) <> 0: raise TestFailed, 'abs(0)'
+if abs(1234) <> 1234: raise TestFailed, 'abs(1234)'
+if abs(-1234) <> 1234: raise TestFailed, 'abs(-1234)'
+if abs(0.0) <> 0.0: raise TestFailed, 'abs(0.0)'
+if abs(3.14) <> 3.14: raise TestFailed, 'abs(3.14)'
+if abs(-3.14) <> 3.14: raise TestFailed, 'abs(-3.14)'
+
+print 'dir'
+if 'x' not in dir(): raise TestFailed, 'dir()'
+if 'modules' not in dir(sys): raise TestFailed, 'dir(sys)'
+
+print 'divmod'
+if divmod(12, 7) <> (1, 5): raise TestFailed, 'divmod(12, 7)'
+if divmod(-12, 7) <> (-2, 2): raise TestFailed, 'divmod(-12, 7)'
+if divmod(12, -7) <> (-2, -2): raise TestFailed, 'divmod(12, -7)'
+if divmod(-12, -7) <> (1, -5): raise TestFailed, 'divmod(-12, -7)'
+
+print 'eval'
+if eval('1+1') <> 2: raise TestFailed, 'eval(\'1+1\')'
+
+print 'exec'
+exec('z=1+1\n')
+if z <> 2: raise TestFailed, 'exec(\'z=1+1\'\\n)'
+
+print 'float'
+if float(3.14) <> 3.14: raise TestFailed, 'float(3.14)'
+if float(314) <> 314.0: raise TestFailed, 'float(314)'
+
+print 'input'
+# Can't test in a script
+
+print 'int'
+if int(100) <> 100: raise TestFailed, 'int(100)'
+if int(3.14) <> 3: raise TestFailed, 'int(3.14)'
+
+print 'len'
+if len('123') <> 3: raise TestFailed, 'len(\'123\')'
+if len(()) <> 0: raise TestFailed, 'len(())'
+if len((1, 2, 3, 4)) <> 4: raise TestFailed, 'len((1, 2, 3, 4))'
+if len([1, 2, 3, 4]) <> 4: raise TestFailed, 'len([1, 2, 3, 4])'
+if len({}) <> 0: raise TestFailed, 'len({})'
+
+print 'min'
+if min('123123') <> '1': raise TestFailed, 'min(\'123123\')'
+if min(1, 2, 3) <> 1: raise TestFailed, 'min(1, 2, 3)'
+if min((1, 2, 3, 1, 2, 3)) <> 1: raise TestFailed, 'min((1, 2, 3, 1, 2, 3))'
+if min([1, 2, 3, 1, 2, 3]) <> 1: raise TestFailed, 'min([1, 2, 3, 1, 2, 3])'
+
+print 'max'
+if max('123123') <> '3': raise TestFailed, 'max(\'123123\')'
+if max(1, 2, 3) <> 3: raise TestFailed, 'max(1, 2, 3)'
+if max((1, 2, 3, 1, 2, 3)) <> 3: raise TestFailed, 'max((1, 2, 3, 1, 2, 3))'
+if max([1, 2, 3, 1, 2, 3]) <> 3: raise TestFailed, 'max([1, 2, 3, 1, 2, 3])'
+
+print 'open'
+print 'NB! This test creates a file named "@test" in the current directory.'
+fp = open('@test', 'w')
+fp.write('The quick brown fox jumps over the lazy dog')
+fp.write('.\n')
+fp.write('Dear John\n')
+fp.write('XXX'*100)
+fp.write('YYY'*100)
+fp.close()
+del fp
+fp = open('@test', 'r')
+if fp.readline() <> 'The quick brown fox jumps over the lazy dog.\n':
+ raise TestFailed, 'readline()'
+if fp.readline(4) <> 'Dear': raise TestFailed, 'readline(4) # short'
+if fp.readline(100) <> ' John\n': raise TestFailed, 'readline(100)'
+if fp.read(300) <> 'XXX'*100: raise TestFailed, 'read(300)'
+if fp.read(1000) <> 'YYY'*100: raise TestFailed, 'read(1000) # truncate'
+fp.close()
+del fp
+
+print 'range'
+if range(3) <> [0, 1, 2]: raise TestFailed, 'range(3)'
+if range(1, 5) <> [1, 2, 3, 4]: raise TestFailed, 'range(1, 5)'
+if range(0) <> []: raise TestFailed, 'range(0)'
+if range(-3) <> []: raise TestFailed, 'range(-3)'
+if range(1, 10, 3) <> [1, 4, 7]: raise TestFailed, 'range(1, 10, 3)'
+if range(5, -5, -3) <> [5, 2, -1, -4]: raise TestFailed, 'range(5, -5, -3)'
+
+print 'raw_input'
+savestdin = sys.stdin
+try:
+ sys.stdin = open('@test', 'r')
+ if raw_input() <> 'The quick brown fox jumps over the lazy dog.':
+ raise TestFailed, 'raw_input()'
+ if raw_input('testing\n') <> 'Dear John':
+ raise TestFailed, 'raw_input(\'testing\\n\')'
+finally:
+ sys.stdin = savestdin
+
+print 'reload'
+import string
+reload(string)
+
+print 'type'
+if type('') <> type('123') or type('') = type(()):
+ raise TestFailed, 'type()'
+
+
+print 'Passed all tests.'
+
+try:
+ import mac
+ unlink = mac.unlink
+except NameError:
+ try:
+ import posix
+ unlink = posix.unlink
+ except NameError:
+ pass
+
+unlink('@test')
+print 'Unlinked @test'
--- /dev/null
+# Module 'maccache'
+#
+# Maintain a cache of listdir(), isdir(), isfile() or exists() outcomes.
+
+import mac
+import macpath
+
+
+# The cache.
+# Keys are absolute pathnames;
+# values are 0 (nothing), 1 (file) or [...] (dir).
+#
+cache = {}
+
+
+# Current working directory.
+#
+cwd = mac.getcwd()
+
+
+# Constants.
+#
+NONE = 0
+FILE = 1
+LISTTYPE = type([])
+
+def _stat(name):
+ name = macpath.cat(cwd, name)
+ if cache.has_key(name):
+ return cache[name]
+ if macpath.isfile(name):
+ cache[name] = FILE
+ return FILE
+ try:
+ list = mac.listdir(name)
+ except:
+ cache[name] = NONE
+ return NONE
+ cache[name] = list
+ if name[-1:] = ':': cache[name[:-1]] = list
+ else: cache[name+':'] = list
+ return list
+
+def isdir(name):
+ st = _stat(name)
+ return type(st) = LISTTYPE
+
+def isfile(name):
+ st = _stat(name)
+ return st = FILE
+
+def exists(name):
+ st = _stat(name)
+ return st <> NONE
+
+def listdir(name):
+ st = _stat(name)
+ if type(st) = LISTTYPE:
+ return st
+ else:
+ raise RuntimeError, 'list non-directory'
projects / thirdparty / Python / cpython.git / commitdiff
