v811_spc009/external/antlr/runtime/JavaScript/tests/functional/rhino-python.input

"""This is a substantially improved version of the older Interpreter.py demo
It creates a simple GUI JPython console window with simple history
as well as the ability to interupt running code (with the ESC key).

Like Interpreter.py, this is still just a demo, and needs substantial
work before serious use.

Thanks to Geza Groma (groma@everx.szbk.u-szeged.hu) for several valuable
ideas for this tool -- his JPConsole is a more refined implementation
of similar ideas.
"""

from Styles import Styles
from Keymap import Keymap

from pawt import swing, colors
from java.awt.event.KeyEvent import VK_UP, VK_DOWN
from java.awt.event import ActionEvent
from java.lang import Thread, System
from code import compile_command
import string, sys, re

class OutputBuffer:
	def __init__(self, console, stylename):
		self.console = console
		self.stylename = stylename
		
	def flush(self):
		pass
		
	def write(self, text):
		self.console.write(text, self.stylename)

class Console:
	def __init__(self, styles=None, keymap=None):
		if styles is None:
			styles = Styles()
			basic = styles.add('normal', tabsize=3, fontSize=12, fontFamily="Courier")
			styles.add('error', parent=basic, foreground=colors.red)
			styles.add('output', parent=basic, foreground=colors.blue)
			styles.add('input', parent=basic, foreground=colors.black)
			styles.add('prompt', parent=basic, foreground=colors.purple)
		self.styles = styles
		
		# This is a hack to get at an inner class
		# This will not be required in JPython-1.1
		ForegroundAction = getattr(swing.text, 'StyledEditorKit$ForegroundAction')
		self.inputAction = ForegroundAction("start input", colors.black)

		if keymap is None:
			keymap = Keymap()
		keymap.bind('enter', self.enter)
		keymap.bind('tab', self.tab)
		keymap.bind('escape', self.escape)
		keymap.bind('up', self.uphistory)
		keymap.bind('down', self.downhistory)
		
		self.keymap = keymap
		
		self.document = swing.text.DefaultStyledDocument(self.styles)
		self.document.setLogicalStyle(0, self.styles.get('normal'))

		self.textpane = swing.JTextPane(self.document)
		self.textpane.keymap = self.keymap
		
		self.history = []
		self.oldHistoryLength = 0
		self.historyPosition = 0
		
		self.command = []
		self.locals = {}

	def write(self, text, stylename='normal'):
		style = self.styles.get(stylename)
		self.document.insertString(self.document.length, text, style)
		
	def beep(self):
		self.textpane.toolkit.beep()

	def startUserInput(self, prompt=None):
		if prompt is not None:
			self.write(prompt, 'prompt')
		self.startInput = self.document.createPosition(self.document.length-1)
		#self.document.setCharacterAttributes(self.document.length-1, 1, self.styles.get('input'), 1)
		self.textpane.caretPosition = self.document.length
		ae = ActionEvent(self.textpane, ActionEvent.ACTION_PERFORMED, 'start input')
		self.inputAction.actionPerformed(ae)

	def getinput(self):
		offset = self.startInput.offset
		line = self.document.getText(offset+1, self.document.length-offset)
		return string.rstrip(line)

	def replaceinput(self, text):
		offset = self.startInput.offset + 1
		self.document.remove(offset, self.document.length-offset)
		self.write(text, 'input')
		
	def enter(self):
		line = self.getinput()
		self.write('\n', 'input')
		
		self.history.append(line)
		self.handleLine(line)
		
	def gethistory(self, direction):
		historyLength = len(self.history)
		if self.oldHistoryLength < historyLength:
			# new line was entered after last call
			self.oldHistoryLength = historyLength
			if self.history[self.historyPosition] != self.history[-1]:
				self.historyPosition = historyLength

		pos = self.historyPosition + direction

		if 0 <= pos < historyLength:
			self.historyPosition = pos
			self.replaceinput(self.history[pos])
		else:
			self.beep()

	def uphistory(self):
		self.gethistory(-1)

	def downhistory(self):
		self.gethistory(1)

	def tab(self):
		self.write('\t', 'input')
		
	def escape(self):
		if (not hasattr(self, 'pythonThread') or self.pythonThread is None or not self.pythonThread.alive):
			self.beep()
			return
			
		self.pythonThread.stopPython()

	def capturePythonOutput(self, stdoutStyle='output', stderrStyle='error'):
		import sys
		sys.stdout = OutputBuffer(self, stdoutStyle)
		sys.stderr = OutputBuffer(self, stderrStyle)

	def handleLine(self, text):
		self.command.append(text)
		
		try:
			code = compile_command(string.join(self.command, '\n'))
		except SyntaxError:
			traceback.print_exc(0)
			self.command = []
			self.startUserInput(str(sys.ps1)+'\t')
			return

		if code is None:
			self.startUserInput(str(sys.ps2)+'\t')
			return
		
		self.command = []
		
		pt = PythonThread(code, self)
		self.pythonThread = pt
		pt.start()
		
	def newInput(self):
		self.startUserInput(str(sys.ps1)+'\t')
		
import traceback

class PythonThread(Thread):
	def __init__(self, code, console):
		self.code = code
		self.console = console
		self.locals = console.locals
		
	def run(self):
		try:
			exec self.code in self.locals
			
		#Include these lines to actually exit on a sys.exit() call
		#except SystemExit, value:
		#	raise SystemExit, value
		
		except:
			exc_type, exc_value, exc_traceback = sys.exc_info()
			l = len(traceback.extract_tb(sys.exc_traceback))
			try:
				1/0
			except:
				m = len(traceback.extract_tb(sys.exc_traceback))
			traceback.print_exception(exc_type, exc_value, exc_traceback, l-m)
			
		self.console.newInput()

	def stopPython(self):
		#Should spend 2 seconds trying to kill thread in nice Python style first...
		self.stop()

header = """\
JPython %(version)s on %(platform)s
%(copyright)s
""" % {'version':sys.version, 'platform':sys.platform, 'copyright':sys.copyright}

if __name__ == '__main__':
	c = Console()
	pane = swing.JScrollPane(c.textpane)
	swing.test(pane, size=(500,400), name='JPython Console')
	c.write(header, 'output')
	c.capturePythonOutput()
	c.textpane.requestFocus()
	c.newInput()