cpython/Mac/Tools/IDE/PyInteractive.py

import string
import sys
import traceback


try:
	sys.ps1
except AttributeError:
	sys.ps1 = ">>> "
try:
	sys.ps2
except AttributeError:
	sys.ps2 = "... "


def print_exc(limit=None, file=None):
	if not file:
		file = sys.stderr
	# we're going to skip the outermost traceback object, we don't
	# want people to see the line which excecuted their code.
	tb = sys.exc_traceback
	if tb:
		tb = tb.tb_next
	try:
		sys.last_type = sys.exc_type
		sys.last_value = sys.exc_value
		sys.last_traceback = tb
		traceback.print_exception(sys.last_type, sys.last_value, 
					sys.last_traceback, limit, file)
	except:
		print '--- hola! ---'
		traceback.print_exception(sys.exc_type, sys.exc_value, 
					sys.exc_traceback, limit, file)


class PyInteractive:
	
	def __init__(self):
		import codeop
		self._pybuf = ""
		self._compile = codeop.Compile()
	
	def executeline(self, stuff, out = None, env = None):
		if env is None:
			import __main__
			env = __main__.__dict__
		if out:
			saveerr, saveout = sys.stderr, sys.stdout
			sys.stderr = sys.stdout = out
		try:
			if self._pybuf:
				self._pybuf = self._pybuf + '\n' + stuff
			else:
				self._pybuf = stuff
			
			# Compile three times: as is, with \n, and with \n\n appended.
			# If it compiles as is, it's complete.  If it compiles with
			# one \n appended, we expect more.  If it doesn't compile
			# either way, we compare the error we get when compiling with
			# \n or \n\n appended.  If the errors are the same, the code
			# is broken.  But if the errors are different, we expect more.
			# Not intuitive; not even guaranteed to hold in future
			# releases; but this matches the compiler's behavior in Python
			# 1.4 and 1.5.
			err = err1 = err2 = None
			code = code1 = code2 = None
			
			# quickly get out of here when the line is 'empty' or is a comment
			stripped = string.strip(self._pybuf)
			if not stripped or stripped[0] == '#':
				self._pybuf = ''
				sys.stdout.write(sys.ps1)
				sys.stdout.flush()
				return
			
			try:
				code = self._compile(self._pybuf, "<input>", "single")
			except SyntaxError, err:
				pass
			except:
				# OverflowError. More?
				print_exc()
				self._pybuf = ""
				sys.stdout.write(sys.ps1)
				sys.stdout.flush()
				return
			
			try:
				code1 = self._compile(self._pybuf + "\n", "<input>", "single")
			except SyntaxError, err1:
				pass
			
			try:
				code2 = self._compile(self._pybuf + "\n\n", "<input>", "single")
			except SyntaxError, err2:
				pass
			
			if code:
				try:
					exec code in env
				except:
					print_exc()
				self._pybuf = ""
			elif code1:
				pass
			elif err1 == err2 or (not stuff and self._pybuf):
				print_exc()
				self._pybuf = ""
			if self._pybuf:
				sys.stdout.write(sys.ps2)
				sys.stdout.flush()
			else:
				sys.stdout.write(sys.ps1)
				sys.stdout.flush()
		finally:
			if out:
				sys.stderr, sys.stdout = saveerr, saveout