mirror of
https://github.com/python/cpython
synced 2024-10-20 03:18:48 +00:00
a93b848e33
possible to use this in PythonWin, and to replace Fredrik Lundh's PythonInterpreter class. Fredrik is credited with the class' API.
266 lines
7.7 KiB
Python
266 lines
7.7 KiB
Python
"""Utilities dealing with code objects."""
|
|
|
|
import sys
|
|
import string
|
|
import traceback
|
|
|
|
def compile_command(source, filename="<input>", symbol="single"):
|
|
r"""Compile a command and determine whether it is incomplete.
|
|
|
|
Arguments:
|
|
|
|
source -- the source string; may contain \n characters
|
|
filename -- optional filename from which source was read; default "<input>"
|
|
symbol -- optional grammar start symbol; "single" (default) or "eval"
|
|
|
|
Return value / exception raised:
|
|
|
|
- Return a code object if the command is complete and valid
|
|
- Return None if the command is incomplete
|
|
- Raise SyntaxError if the command is a syntax error
|
|
|
|
Approach:
|
|
|
|
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
|
|
|
|
try:
|
|
code = compile(source, filename, symbol)
|
|
except SyntaxError, err:
|
|
pass
|
|
|
|
try:
|
|
code1 = compile(source + "\n", filename, symbol)
|
|
except SyntaxError, err1:
|
|
pass
|
|
|
|
try:
|
|
code2 = compile(source + "\n\n", filename, symbol)
|
|
except SyntaxError, err2:
|
|
pass
|
|
|
|
if code:
|
|
return code
|
|
try:
|
|
e1 = err1.__dict__
|
|
except AttributeError:
|
|
e1 = err1
|
|
try:
|
|
e2 = err2.__dict__
|
|
except AttributeError:
|
|
e2 = err2
|
|
if not code1 and e1 == e2:
|
|
raise SyntaxError, err1
|
|
|
|
|
|
class InteractiveConsole:
|
|
"""Closely emulate the behavior of the interactive Python interpreter.
|
|
|
|
After code by Jeff Epler and Fredrik Lundh.
|
|
"""
|
|
|
|
def __init__(self, filename="<console>", locals=None):
|
|
"""Constructor.
|
|
|
|
The optional filename argument specifies the (file)name of the
|
|
input stream; it will show up in tracebacks. It defaults to
|
|
'<console>'.
|
|
|
|
"""
|
|
self.filename = filename
|
|
if locals is None:
|
|
locals = {}
|
|
self.locals = locals
|
|
self.resetbuffer()
|
|
|
|
def resetbuffer(self):
|
|
"""Reset the input buffer (but not the variables!)."""
|
|
self.buffer = []
|
|
|
|
def interact(self, banner=None):
|
|
"""Closely emulate the interactive Python console."""
|
|
try:
|
|
sys.ps1
|
|
except AttributeError:
|
|
sys.ps1 = ">>> "
|
|
try:
|
|
sys.ps2
|
|
except AttributeError:
|
|
sys.ps2 = "... "
|
|
if banner is None:
|
|
self.write("Python %s on %s\n%s\n(%s)\n" %
|
|
(sys.version, sys.platform, sys.copyright,
|
|
self.__class__.__name__))
|
|
else:
|
|
self.write("%s\n" % str(banner))
|
|
more = 0
|
|
while 1:
|
|
try:
|
|
if more:
|
|
prompt = sys.ps2
|
|
else:
|
|
prompt = sys.ps1
|
|
try:
|
|
line = self.raw_input(prompt)
|
|
except EOFError:
|
|
self.write("\n")
|
|
break
|
|
else:
|
|
more = self.push(line)
|
|
except KeyboardInterrupt:
|
|
self.write("\nKeyboardInterrupt\n")
|
|
self.resetbuffer()
|
|
more = 0
|
|
|
|
def push(self, line):
|
|
"""Push a line to the interpreter.
|
|
|
|
The line should not have a trailing newline.
|
|
|
|
One of three things will happen:
|
|
|
|
1) The input is incorrect; compile_command() raised
|
|
SyntaxError. A syntax traceback will be printed.
|
|
|
|
2) The input is incomplete, and more input is required;
|
|
compile_command() returned None.
|
|
|
|
3) The input is complete; compile_command() returned a code
|
|
object. The code is executed. When an exception occurs, a
|
|
traceback is printed. All exceptions are caught except
|
|
SystemExit, which is reraised.
|
|
|
|
The return value is 1 in case 2, 0 in the other cases. (The
|
|
return value can be used to decide whether to use sys.ps1 or
|
|
sys.ps2 to prompt the next line.)
|
|
|
|
A note about KeyboardInterrupt: this exception may occur
|
|
elsewhere in this code, and will not always be caught. The
|
|
caller should be prepared to deal with it.
|
|
|
|
"""
|
|
self.buffer.append(line)
|
|
|
|
try:
|
|
x = compile_command(string.join(self.buffer, "\n"),
|
|
filename=self.filename)
|
|
except SyntaxError:
|
|
# Case 1
|
|
self.showsyntaxerror()
|
|
self.resetbuffer()
|
|
return 0
|
|
|
|
if x is None:
|
|
# Case 2
|
|
return 1
|
|
|
|
# Case 3
|
|
try:
|
|
exec x in self.locals
|
|
except SystemExit:
|
|
raise
|
|
except:
|
|
self.showtraceback()
|
|
self.resetbuffer()
|
|
return 0
|
|
|
|
def showsyntaxerror(self):
|
|
"""Display the syntax error that just occurred.
|
|
|
|
This doesn't display a stack trace because there isn't one.
|
|
|
|
The output is written by self.write(), below.
|
|
|
|
"""
|
|
type, value = sys.exc_info()[:2]
|
|
# Work hard to stuff the correct filename in the exception
|
|
try:
|
|
msg, (filename, lineno, offset, line) = value
|
|
except:
|
|
pass
|
|
else:
|
|
try:
|
|
value = SyntaxError(msg, (self.filename, lineno, offset, line))
|
|
except:
|
|
value = msg, (self.filename, lineno, offset, line)
|
|
list = traceback.format_exception_only(type, value)
|
|
map(self.write, list)
|
|
|
|
def showtraceback(self):
|
|
"""Display the exception that just occurred.
|
|
|
|
We remove the first stack item because it is our own code.
|
|
|
|
The output is written by self.write(), below.
|
|
|
|
"""
|
|
try:
|
|
type, value, tb = sys.exc_info()
|
|
tblist = traceback.extract_tb(tb)
|
|
del tblist[0]
|
|
list = traceback.format_list(tblist)
|
|
list[len(list):] = traceback.format_exception_only(type, value)
|
|
finally:
|
|
tblist = tb = None
|
|
map(self.write, list)
|
|
|
|
def write(self, data):
|
|
"""Write a string.
|
|
|
|
The base implementation writes to sys.stderr; a subclass may
|
|
replace this with a different implementation.
|
|
|
|
"""
|
|
sys.stderr.write(data)
|
|
|
|
def raw_input(self, prompt=""):
|
|
"""Write a prompt and read a line.
|
|
|
|
The returned line does not include the trailing newline.
|
|
When the user enters the EOF key sequence, EOFError is raised.
|
|
|
|
The base implementation uses the built-in function
|
|
raw_input(); a subclass may replace this with a different
|
|
implementation.
|
|
|
|
"""
|
|
return raw_input(prompt)
|
|
|
|
|
|
def interact(banner=None, readfunc=None, locals=None):
|
|
"""Closely emulate the interactive Python interpreter.
|
|
|
|
This is a backwards compatible interface to the InteractiveConsole
|
|
class. It attempts to import the readline module to enable GNU
|
|
readline if it is available.
|
|
|
|
Arguments (all optional, all default to None):
|
|
|
|
banner -- passed to InteractiveConsole.interact()
|
|
readfunc -- if not None, replaces InteractiveConsole.raw_input()
|
|
locals -- passed to InteractiveConsole.__init__()
|
|
|
|
"""
|
|
try:
|
|
import readline
|
|
except:
|
|
pass
|
|
console = InteractiveConsole(locals=locals)
|
|
if readfunc is not None:
|
|
console.raw_input = readfunc
|
|
console.interact(banner)
|
|
|
|
if __name__ == '__main__':
|
|
interact()
|