/python/helpers/pydev/_pydevd_bundle/pydevconsole_code_for_ironpython.py
Python | 513 lines | 492 code | 1 blank | 20 comment | 0 complexity | aa13976f230223a2242e62b827167b23 MD5 | raw file
Possible License(s): BSD-3-Clause, Apache-2.0, MPL-2.0-no-copyleft-exception, MIT, EPL-1.0, AGPL-1.0
- """Utilities needed to emulate Python's interactive interpreter.
- """
- # Inspired by similar code by Jeff Epler and Fredrik Lundh.
- import sys
- import traceback
- #START --------------------------- from codeop import CommandCompiler, compile_command
- #START --------------------------- from codeop import CommandCompiler, compile_command
- #START --------------------------- from codeop import CommandCompiler, compile_command
- #START --------------------------- from codeop import CommandCompiler, compile_command
- #START --------------------------- from codeop import CommandCompiler, compile_command
- r"""Utilities to compile possibly incomplete Python source code.
- This module provides two interfaces, broadly similar to the builtin
- function compile(), which take program text, a filename and a 'mode'
- and:
- - Return code object if the command is complete and valid
- - Return None if the command is incomplete
- - Raise SyntaxError, ValueError or OverflowError if the command is a
- syntax error (OverflowError and ValueError can be produced by
- malformed literals).
- Approach:
- First, check if the source consists entirely of blank lines and
- comments; if so, replace it with 'pass', because the built-in
- parser doesn't always do the right thing for these.
- 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 from Python 1.4
- through 2.2, at least.
- Caveat:
- It is possible (but not likely) that the parser stops parsing with a
- successful outcome before reaching the end of the source; in this
- case, trailing symbols may be ignored instead of causing an error.
- For example, a backslash followed by two newlines may be followed by
- arbitrary garbage. This will be fixed once the API for the parser is
- better.
- The two interfaces are:
- compile_command(source, filename, symbol):
- Compiles a single command in the manner described above.
- CommandCompiler():
- Instances of this class have __call__ methods identical in
- signature to compile_command; the difference is that if the
- instance compiles program text containing a __future__ statement,
- the instance 'remembers' and compiles all subsequent program texts
- with the statement in force.
- The module also provides another class:
- Compile():
- Instances of this class act like the built-in function compile,
- but with 'memory' in the sense described above.
- """
- import __future__
- _features = [getattr(__future__, fname)
- for fname in __future__.all_feature_names]
- __all__ = ["compile_command", "Compile", "CommandCompiler"]
- PyCF_DONT_IMPLY_DEDENT = 0x200 # Matches pythonrun.h
- def _maybe_compile(compiler, source, filename, symbol):
- # Check for source consisting of only blank lines and comments
- for line in source.split("\n"):
- line = line.strip()
- if line and line[0] != '#':
- break # Leave it alone
- else:
- if symbol != "eval":
- source = "pass" # Replace it with a 'pass' statement
- err = err1 = err2 = None
- code = code1 = code2 = None
- try:
- code = compiler(source, filename, symbol)
- except SyntaxError:
- pass
- try:
- code1 = compiler(source + "\n", filename, symbol)
- except SyntaxError as err1:
- pass
- try:
- code2 = compiler(source + "\n\n", filename, symbol)
- except SyntaxError as err2:
- pass
- if code:
- return code
- if not code1 and repr(err1) == repr(err2):
- raise SyntaxError(err1)
- def _compile(source, filename, symbol):
- return compile(source, filename, symbol, PyCF_DONT_IMPLY_DEDENT)
- 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 / exceptions raised:
- - Return a code object if the command is complete and valid
- - Return None if the command is incomplete
- - Raise SyntaxError, ValueError or OverflowError if the command is a
- syntax error (OverflowError and ValueError can be produced by
- malformed literals).
- """
- return _maybe_compile(_compile, source, filename, symbol)
- class Compile:
- """Instances of this class behave much like the built-in compile
- function, but if one is used to compile text containing a future
- statement, it "remembers" and compiles all subsequent program texts
- with the statement in force."""
- def __init__(self):
- self.flags = PyCF_DONT_IMPLY_DEDENT
- def __call__(self, source, filename, symbol):
- codeob = compile(source, filename, symbol, self.flags, 1)
- for feature in _features:
- if codeob.co_flags & feature.compiler_flag:
- self.flags |= feature.compiler_flag
- return codeob
- class CommandCompiler:
- """Instances of this class have __call__ methods identical in
- signature to compile_command; the difference is that if the
- instance compiles program text containing a __future__ statement,
- the instance 'remembers' and compiles all subsequent program texts
- with the statement in force."""
- def __init__(self,):
- self.compiler = Compile()
- def __call__(self, 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 / exceptions raised:
- - Return a code object if the command is complete and valid
- - Return None if the command is incomplete
- - Raise SyntaxError, ValueError or OverflowError if the command is a
- syntax error (OverflowError and ValueError can be produced by
- malformed literals).
- """
- return _maybe_compile(self.compiler, source, filename, symbol)
- #END --------------------------- from codeop import CommandCompiler, compile_command
- #END --------------------------- from codeop import CommandCompiler, compile_command
- #END --------------------------- from codeop import CommandCompiler, compile_command
- #END --------------------------- from codeop import CommandCompiler, compile_command
- #END --------------------------- from codeop import CommandCompiler, compile_command
- __all__ = ["InteractiveInterpreter", "InteractiveConsole", "interact",
- "compile_command"]
- def softspace(file, newvalue):
- oldvalue = 0
- try:
- oldvalue = file.softspace
- except AttributeError:
- pass
- try:
- file.softspace = newvalue
- except (AttributeError, TypeError):
- # "attribute-less object" or "read-only attributes"
- pass
- return oldvalue
- class InteractiveInterpreter:
- """Base class for InteractiveConsole.
- This class deals with parsing and interpreter state (the user's
- namespace); it doesn't deal with input buffering or prompting or
- input file naming (the filename is always passed in explicitly).
- """
- def __init__(self, locals=None):
- """Constructor.
- The optional 'locals' argument specifies the dictionary in
- which code will be executed; it defaults to a newly created
- dictionary with key "__name__" set to "__console__" and key
- "__doc__" set to None.
- """
- if locals is None:
- locals = {"__name__": "__console__", "__doc__": None}
- self.locals = locals
- self.compile = CommandCompiler()
- def runsource(self, source, filename="<input>", symbol="single"):
- """Compile and run some source in the interpreter.
- Arguments are as for compile_command().
- One several things can happen:
- 1) The input is incorrect; compile_command() raised an
- exception (SyntaxError or OverflowError). A syntax traceback
- will be printed by calling the showsyntaxerror() method.
- 2) The input is incomplete, and more input is required;
- compile_command() returned None. Nothing happens.
- 3) The input is complete; compile_command() returned a code
- object. The code is executed by calling self.runcode() (which
- also handles run-time exceptions, except for SystemExit).
- The return value is True in case 2, False in the other cases (unless
- an exception is raised). The return value can be used to
- decide whether to use sys.ps1 or sys.ps2 to prompt the next
- line.
- """
- try:
- code = self.compile(source, filename, symbol)
- except (OverflowError, SyntaxError, ValueError):
- # Case 1
- self.showsyntaxerror(filename)
- return False
- if code is None:
- # Case 2
- return True
- # Case 3
- self.runcode(code)
- return False
- def runcode(self, code):
- """Execute a code object.
- When an exception occurs, self.showtraceback() is called to
- display a traceback. All exceptions are caught except
- SystemExit, which is reraised.
- A note about KeyboardInterrupt: this exception may occur
- elsewhere in this code, and may not always be caught. The
- caller should be prepared to deal with it.
- """
- try:
- exec code in self.locals
- except SystemExit:
- raise
- except:
- self.showtraceback()
- else:
- if softspace(sys.stdout, 0):
- sys.stdout.write('\n')
- def showsyntaxerror(self, filename=None):
- """Display the syntax error that just occurred.
- This doesn't display a stack trace because there isn't one.
- If a filename is given, it is stuffed in the exception instead
- of what was there before (because Python's parser always uses
- "<string>" when reading from a string).
- The output is written by self.write(), below.
- """
- type, value, sys.last_traceback = sys.exc_info()
- sys.last_type = type
- sys.last_value = value
- if filename and type is SyntaxError:
- # Work hard to stuff the correct filename in the exception
- try:
- msg, (dummy_filename, lineno, offset, line) = value
- except:
- # Not the format we expect; leave it alone
- pass
- else:
- # Stuff in the right filename
- value = SyntaxError(msg, (filename, lineno, offset, line))
- sys.last_value = value
- 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()
- sys.last_type = type
- sys.last_value = value
- sys.last_traceback = tb
- tblist = traceback.extract_tb(tb)
- del tblist[:1]
- list = traceback.format_list(tblist)
- if list:
- list.insert(0, "Traceback (most recent call last):\n")
- 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)
- class InteractiveConsole(InteractiveInterpreter):
- """Closely emulate the behavior of the interactive Python interpreter.
- This class builds on InteractiveInterpreter and adds prompting
- using the familiar sys.ps1 and sys.ps2, and input buffering.
- """
- def __init__(self, locals=None, filename="<console>"):
- """Constructor.
- The optional locals argument will be passed to the
- InteractiveInterpreter base class.
- The optional filename argument should specify the (file)name
- of the input stream; it will show up in tracebacks.
- """
- InteractiveInterpreter.__init__(self, locals)
- self.filename = filename
- self.resetbuffer()
- def resetbuffer(self):
- """Reset the input buffer."""
- self.buffer = []
- def interact(self, banner=None):
- """Closely emulate the interactive Python console.
- The optional banner argument specify the banner to print
- before the first interaction; by default it prints a banner
- similar to the one printed by the real Python interpreter,
- followed by the current class name in parentheses (so as not
- to confuse this with the real interpreter -- since it's so
- close!).
- """
- try:
- sys.ps1 #@UndefinedVariable
- except AttributeError:
- sys.ps1 = ">>> "
- try:
- sys.ps2 #@UndefinedVariable
- except AttributeError:
- sys.ps2 = "... "
- cprt = 'Type "help", "copyright", "credits" or "license" for more information.'
- if banner is None:
- self.write("Python %s on %s\n%s\n(%s)\n" %
- (sys.version, sys.platform, cprt,
- self.__class__.__name__))
- else:
- self.write("%s\n" % str(banner))
- more = 0
- while 1:
- try:
- if more:
- prompt = sys.ps2 #@UndefinedVariable
- else:
- prompt = sys.ps1 #@UndefinedVariable
- try:
- line = self.raw_input(prompt)
- # Can be None if sys.stdin was redefined
- encoding = getattr(sys.stdin, "encoding", None)
- if encoding and not isinstance(line, unicode):
- line = line.decode(encoding)
- 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; it may have
- internal newlines. The line is appended to a buffer and the
- interpreter's runsource() method is called with the
- concatenated contents of the buffer as source. If this
- indicates that the command was executed or invalid, the buffer
- is reset; otherwise, the command is incomplete, and the buffer
- is left as it was after the line was appended. The return
- value is 1 if more input is required, 0 if the line was dealt
- with in some way (this is the same as runsource()).
- """
- self.buffer.append(line)
- source = "\n".join(self.buffer)
- more = self.runsource(source, self.filename)
- if not more:
- self.resetbuffer()
- return more
- 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, local=None):
- """Closely emulate the interactive Python interpreter.
- This is a backwards compatible interface to the InteractiveConsole
- class. When readfunc is not specified, 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()
- local -- passed to InteractiveInterpreter.__init__()
- """
- console = InteractiveConsole(local)
- if readfunc is not None:
- console.raw_input = readfunc
- else:
- try:
- import readline
- except ImportError:
- pass
- console.interact(banner)
- if __name__ == '__main__':
- import pdb
- pdb.run("interact()\n")