cpython/Demo/stdwin/python.py

504 lines
14 KiB
Python
Executable File

#! /usr/local/python
# A STDWIN-based front end for the Python interpreter.
#
# This is useful if you want to avoid console I/O and instead
# use text windows to issue commands to the interpreter.
#
# It supports multiple interpreter windows, each with its own context.
#
# BUGS AND CAVEATS:
#
# Although this supports multiple windows, the whole application
# is deaf and dumb when a command is running in one window.
#
# Everything written to stdout or stderr is saved on a file which
# is inserted in the window at the next input request.
#
# On UNIX (using X11), interrupts typed in the window will not be
# seen until the next input request. (On the Mac, interrupts work.)
#
# Direct input from stdin should not be attempted.
import sys
import builtin
import stdwin
from stdwinevents import *
import rand
import mainloop
import os
# Filename used to capture output from commands; change to suit your taste
#
OUTFILE = '@python.stdout.tmp'
# Stack of windows waiting for [raw_]input().
# Element [0] is the top.
# If there are multiple windows waiting for input, only the
# one on top of the stack can accept input, because the way
# raw_input() is implemented (using recursive mainloop() calls).
#
inputwindows = []
# Exception raised when input is available.
#
InputAvailable = 'input available for raw_input (not an error)'
# Main program. Create the window and call the mainloop.
#
def main():
# Hack so 'import python' won't load another copy
# of this if we were loaded though 'python python.py'.
# (Should really look at sys.argv[0]...)
if 'inputwindows' in dir(sys.modules['__main__']) and \
sys.modules['__main__'].inputwindows is inputwindows:
sys.modules['python'] = sys.modules['__main__']
#
win = makewindow()
mainloop.mainloop()
# Create a new window.
#
def makewindow():
# stdwin.setdefscrollbars(0, 1) # Not in Python 0.9.1
# stdwin.setfont('monaco') # Not on UNIX! and not Python 0.9.1
# stdwin.setdefwinsize(stdwin.textwidth('in')*40, stdwin.lineheight() * 24)
win = stdwin.open('Python interpreter ready')
win.editor = win.textcreate((0,0), win.getwinsize())
win.outfile = OUTFILE + `rand.rand()`
win.globals = {} # Dictionary for user's global variables
win.command = '' # Partially read command
win.busy = 0 # Ready to accept a command
win.auto = 1 # [CR] executes command
win.insertOutput = 1 # Insert output at focus.
win.insertError = 1 # Insert error output at focus.
win.setwincursor('ibeam')
win.filename = '' # Empty if no file associated with this window
makefilemenu(win)
makeeditmenu(win)
win.dispatch = pdispatch # Event dispatch function
mainloop.register(win)
return win
# Make a 'File' menu
#
def makefilemenu(win):
win.filemenu = mp = win.menucreate('File')
mp.callback = []
additem(mp, 'New', 'N', do_new)
additem(mp, 'Open...', 'O', do_open)
additem(mp, '', '', None)
additem(mp, 'Close', 'W', do_close)
additem(mp, 'Save', 'S', do_save)
additem(mp, 'Save as...', '', do_saveas)
additem(mp, '', '', None)
additem(mp, 'Quit', 'Q', do_quit)
# Make an 'Edit' menu
#
def makeeditmenu(win):
win.editmenu = mp = win.menucreate('Edit')
mp.callback = []
additem(mp, 'Cut', 'X', do_cut)
additem(mp, 'Copy', 'C', do_copy)
additem(mp, 'Paste', 'V', do_paste)
additem(mp, 'Clear', '', do_clear)
additem(mp, '', '', None)
win.iauto = len(mp.callback)
additem(mp, 'Autoexecute', '', do_auto)
mp.check(win.iauto, win.auto)
win.insertOutputNum = len(mp.callback)
additem(mp, 'Insert Output', '', do_insertOutputOption)
win.insertErrorNum = len(mp.callback)
additem(mp, 'Insert Error', '', do_insertErrorOption)
additem(mp, 'Exec', '\r', do_exec)
# Helper to add a menu item and callback function
#
def additem(mp, text, shortcut, handler):
if shortcut:
mp.additem(text, shortcut)
else:
mp.additem(text)
mp.callback.append(handler)
# Dispatch a single event to the interpreter.
# Resize events cause a resize of the editor.
# Other events are directly sent to the editor.
#
# Exception: WE_COMMAND/WC_RETURN causes the current selection
# (if not empty) or current line (if empty) to be sent to the
# interpreter. (In the future, there should be a way to insert
# newlines in the text; or perhaps Enter or Meta-RETURN should be
# used to trigger execution, like in MPW, though personally I prefer
# using a plain Return to trigger execution, as this is what I want
# in the majority of cases.)
#
# Also, WE_COMMAND/WC_CANCEL cancels any command in progress.
#
def pdispatch(event):
type, win, detail = event
if type == WE_CLOSE:
do_close(win)
elif type == WE_SIZE:
win.editor.move((0, 0), win.getwinsize())
elif type == WE_COMMAND and detail == WC_RETURN:
if win.auto:
do_exec(win)
else:
void = win.editor.event(event)
elif type == WE_COMMAND and detail == WC_CANCEL:
if win.busy:
raise InputAvailable, (EOFError, None)
else:
win.command = ''
settitle(win)
elif type == WE_MENU:
mp, item = detail
mp.callback[item](win)
else:
void = win.editor.event(event)
if win.editor:
# May have been deleted by close...
win.setdocsize(0, win.editor.getrect()[1][1])
if type in (WE_CHAR, WE_COMMAND):
win.editor.setfocus(win.editor.getfocus())
# Helper to set the title of the window.
#
def settitle(win):
if win.filename == '':
win.settitle('Python interpreter ready')
else:
win.settitle(win.filename)
# Helper to replace the text of the focus.
#
def replace(win, text):
win.editor.replace(text)
# Resize the window to display the text
win.setdocsize(0, win.editor.getrect()[1][1]) # update the size before..
win.editor.setfocus(win.editor.getfocus()) # move focus to the change - dml
# File menu handlers
#
def do_new(win):
win = makewindow()
#
def do_open(win):
try:
filename = stdwin.askfile('Open file', '', 0)
win = makewindow()
win.filename = filename
win.editor.replace(open(filename, 'r').read())
win.editor.setfocus(0, 0)
win.settitle(win.filename)
#
except KeyboardInterrupt:
pass # Don't give an error on cancel.
#
def do_save(win):
try:
if win.filename == '':
win.filename = stdwin.askfile('Open file', '', 1)
f = open(win.filename, 'w')
f.write(win.editor.gettext())
#
except KeyboardInterrupt:
pass # Don't give an error on cancel.
def do_saveas(win):
currentFilename = win.filename
win.filename = ''
do_save(win) # Use do_save with empty filename
if win.filename == '': # Restore the name if do_save did not set it.
win.filename = currentFilename
#
def do_close(win):
if win.busy:
stdwin.message('Can\'t close busy window')
return # need to fail if quitting??
win.editor = None # Break circular reference
#del win.editmenu # What about the filemenu??
try:
os.unlink(win.outfile)
except os.error:
pass
mainloop.unregister(win)
#
def do_quit(win):
# Call win.dispatch instead of do_close because there
# may be 'alien' windows in the list.
for win in mainloop.windows:
mainloop.dispatch(WE_CLOSE, win, None) # need to catch failed close
# Edit menu handlers
#
def do_cut(win):
text = win.editor.getfocustext()
if not text:
stdwin.fleep()
return
stdwin.setcutbuffer(0, text)
replace(win, '')
#
def do_copy(win):
text = win.editor.getfocustext()
if not text:
stdwin.fleep()
return
stdwin.setcutbuffer(0, text)
#
def do_paste(win):
text = stdwin.getcutbuffer(0)
if not text:
stdwin.fleep()
return
replace(win, text)
#
def do_clear(win):
replace(win, '')
#
# These would be better in a preferences dialog:
def do_auto(win):
win.auto = (not win.auto)
win.editmenu.check(win.iauto, win.auto)
#
def do_insertOutputOption(win):
win.insertOutput = (not win.insertOutput)
title = ['Append Output', 'Insert Output'][win.insertOutput]
win.editmenu.setitem(win.insertOutputNum, title)
#
def do_insertErrorOption(win):
win.insertError = (not win.insertError)
title = ['Error Dialog', 'Insert Error'][win.insertError]
win.editmenu.setitem(win.insertErrorNum, title)
# Extract a command from the editor and execute it, or pass input to
# an interpreter waiting for it.
# Incomplete commands are merely placed in the window's command buffer.
# All exceptions occurring during the execution are caught and reported.
# (Tracebacks are currently not possible, as the interpreter does not
# save the traceback pointer until it reaches its outermost level.)
#
def do_exec(win):
if win.busy:
if win not in inputwindows:
stdwin.message('Can\'t run recursive commands')
return
if win <> inputwindows[0]:
stdwin.message( \
'Please complete recursive input first')
return
#
# Set text to the string to execute.
a, b = win.editor.getfocus()
alltext = win.editor.gettext()
n = len(alltext)
if a == b:
# There is no selected text, just an insert point;
# so execute the current line.
while 0 < a and alltext[a-1] <> '\n': a = a-1 # Find beginning of line.
while b < n and alltext[b] <> '\n': # Find end of line after b.
b = b+1
text = alltext[a:b] + '\n'
else:
# Execute exactly the selected text.
text = win.editor.getfocustext()
if text[-1:] <> '\n': # Make sure text ends with newline.
text = text + '\n'
while b < n and alltext[b] <> '\n': # Find end of line after b.
b = b+1
#
# Set the focus to expect the output, since there is always something.
# Output will be inserted at end of line after current focus,
# or appended to the end of the text.
b = [n, b][win.insertOutput]
win.editor.setfocus(b, b)
#
# Make sure there is a preceeding newline.
if alltext[b-1:b] <> '\n':
win.editor.replace('\n')
#
#
if win.busy:
# Send it to raw_input() below
raise InputAvailable, (None, text)
#
# Like the real Python interpreter, we want to execute
# single-line commands immediately, but save multi-line
# commands until they are terminated by a blank line.
# Unlike the real Python interpreter, we don't do any syntax
# checking while saving up parts of a multi-line command.
#
# The current heuristic to determine whether a command is
# the first line of a multi-line command simply checks whether
# the command ends in a colon (followed by a newline).
# This is not very robust (comments and continuations will
# confuse it), but it is usable, and simple to implement.
# (It even has the advantage that single-line loops etc.
# don't need te be terminated by a blank line.)
#
if win.command:
# Already continuing
win.command = win.command + text
if win.command[-2:] <> '\n\n':
win.settitle('Unfinished command...')
return # Need more...
else:
# New command
win.command = text
if text[-2:] == ':\n':
win.settitle('Unfinished command...')
return
command = win.command
win.command = ''
win.settitle('Executing command...')
#
# Some hacks: sys.stdout is temporarily redirected to a file,
# so we can intercept the command's output and insert it
# in the editor window; the built-in function raw_input
# and input() are replaced by out versions;
# and a second, undocumented argument
# to exec() is used to specify the directory holding the
# user's global variables. (If this wasn't done, the
# exec would be executed in the current local environment,
# and the user's assignments to globals would be lost...)
#
save_input = builtin.input
save_raw_input = builtin.raw_input
save_stdout = sys.stdout
save_stderr = sys.stderr
iwin = Input().init(win)
try:
builtin.input = iwin.input
builtin.raw_input = iwin.raw_input
sys.stdout = sys.stderr = open(win.outfile, 'w')
win.busy = 1
try:
exec(command, win.globals)
except KeyboardInterrupt:
pass # Don't give an error.
except:
msg = sys.exc_type
if sys.exc_value <> None:
msg = msg + ': ' + `sys.exc_value`
if win.insertError:
stdwin.fleep()
replace(win, msg + '\n')
else:
win.settitle('Unhandled exception')
stdwin.message(msg)
finally:
# Restore redirected I/O in *all* cases
win.busy = 0
sys.stderr = save_stderr
sys.stdout = save_stdout
builtin.raw_input = save_raw_input
builtin.input = save_input
settitle(win)
getoutput(win)
# Read any output the command may have produced back from the file
# and show it. Optionally insert it after the focus, like MPW does,
# or always append at the end.
#
def getoutput(win):
filename = win.outfile
try:
fp = open(filename, 'r')
except:
stdwin.message('Can\'t read output from ' + filename)
return
#out = fp.read() # Not in Python 0.9.1
out = fp.read(10000) # For Python 0.9.1
del fp # Close it
if out or win.insertOutput:
replace(win, out)
# Implementation of input() and raw_input().
# This uses a class only because we must support calls
# with and without arguments; this can't be done normally in Python,
# but the extra, implicit argument for instance methods does the trick.
#
class Input:
#
def init(self, win):
self.win = win
return self
#
def input(args):
# Hack around call with or without argument:
if type(args) == type(()):
self, prompt = args
else:
self, prompt = args, ''
#
return eval(self.raw_input(prompt), self.win.globals)
#
def raw_input(args):
# Hack around call with or without argument:
if type(args) == type(()):
self, prompt = args
else:
self, prompt = args, ''
#
print prompt # Need to terminate with newline.
sys.stdout.close()
sys.stdout = sys.stderr = None
getoutput(self.win)
sys.stdout = sys.stderr = open(self.win.outfile, 'w')
save_title = self.win.gettitle()
n = len(inputwindows)
title = n*'(' + 'Requesting input...' + ')'*n
self.win.settitle(title)
inputwindows.insert(0, self.win)
try:
mainloop.mainloop()
except InputAvailable, (exc, val): # See do_exec above.
if exc:
raise exc, val
if val[-1:] == '\n':
val = val[:-1]
return val
finally:
del inputwindows[0]
self.win.settitle(save_title)
# If we don't catch InputAvailable, something's wrong...
raise EOFError
#
# Currently unused function to test a command's syntax without executing it
#
def testsyntax(s):
import string
lines = string.splitfields(s, '\n')
for i in range(len(lines)): lines[i] = '\t' + lines[i]
lines.insert(0, 'if 0:')
lines.append('')
exec(string.joinfields(lines, '\n'))
# Call the main program.
#
main()