traverseda
/
cpython
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

A fiddled version of the rest of Michael Hudson's SF patch 

#449043 supporting __future__ in simulated shells
which implements PEP 264.
This commit is contained in:
Tim Peters 2001-08-17 22:11:27 +00:00
parent 10d7255249
commit 6cd6a82db9
4 changed files with 157 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
Lib/code.py
View File

@ -7,9 +7,9 @@
import sys
import traceback
from codeop import compile_command
from codeop import CommandCompiler, compile_command
__all__ = ["InteractiveInterpreter","InteractiveConsole","interact",
__all__ = ["InteractiveInterpreter", "InteractiveConsole", "interact",
"compile_command"]
def softspace(file, newvalue):
@ -45,6 +45,7 @@ class InteractiveInterpreter:
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.
@ -71,7 +72,7 @@ class InteractiveInterpreter:
"""
try:
code = compile_command(source, filename, symbol)
code = self.compile(source, filename, symbol)
except (OverflowError, SyntaxError, ValueError):
# Case 1
self.showsyntaxerror(filename)

158
Lib/codeop.py
View File

@ -1,49 +1,69 @@
"""Utility to compile possibly incomplete Python source code."""
r"""Utilities to compile possibly incomplete Python source code.
__all__ = ["compile_command"]
This module provides two interfaces, broadly similar to the builtin
function compile(), that take progam text, a filename and a 'mode'
and:
def compile_command(source, filename="<input>", symbol="single"):
r"""Compile a command and determine whether it is incomplete.
- 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).
Arguments:
Approach:
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"
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.
Return value / exceptions raised:
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.
- Return a code object if the command is complete and valid
- Return None if the command is incomplete
- Raise SyntaxError or OverflowError if the command is a syntax error
(OverflowError if the error is in a numeric constant)
Caveat:
Approach:
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.
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.
The two interfaces are:
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 1.5.2, at least.
compile_command(source, filename, symbol):
Caveat:
Compiles a single command in the manner described above.
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.
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"]
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()
@ -56,17 +76,17 @@ def compile_command(source, filename="<input>", symbol="single"):
code = code1 = code2 = None
try:
code = compile(source, filename, symbol)
code = compiler(source, filename, symbol)
except SyntaxError, err:
pass
try:
code1 = compile(source + "\n", filename, symbol)
code1 = compiler(source + "\n", filename, symbol)
except SyntaxError, err1:
pass
try:
code2 = compile(source + "\n\n", filename, symbol)
code2 = compiler(source + "\n\n", filename, symbol)
except SyntaxError, err2:
pass
@ -82,3 +102,69 @@ def compile_command(source, filename="<input>", symbol="single"):
e2 = err2
if not code1 and e1 == e2:
raise SyntaxError, err1
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 = 0
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)

5
Misc/NEWS
View File

@ -23,6 +23,11 @@ Tests
Core
- Future statements are now effective in simulated interactive shells
(like IDLE). This should "just work" by magic, but read Michael
Hudson's "Future statements in simulated shells" PEP 264 for full
details: <http://python.sf.net/peps/pep-0264.html>.
- The type/class unification (PEP 252-253) was integrated into the
trunk and is not so tentative any more (the exact specification of
some features is still tentative). A lot of work has done on fixing

34
Python/bltinmodule.c
View File

@ -377,10 +377,14 @@ builtin_compile(PyObject *self, PyObject *args)
char *filename;
char *startstr;
int start;
int dont_inherit = 0;
int supplied_flags = 0;
PyCompilerFlags cf;
if (!PyArg_ParseTuple(args, "sss:compile", &str, &filename, &startstr))
if (!PyArg_ParseTuple(args, "sss|ii:compile", &str, &filename,
&startstr, &supplied_flags, &dont_inherit))
return NULL;
if (strcmp(startstr, "exec") == 0)
start = Py_file_input;
else if (strcmp(startstr, "eval") == 0)
@ -392,21 +396,35 @@ builtin_compile(PyObject *self, PyObject *args)
"compile() arg 3 must be 'exec' or 'eval' or 'single'");
return NULL;
}
cf.cf_flags = 0;
if (PyEval_MergeCompilerFlags(&cf))
return Py_CompileStringFlags(str, filename, start, &cf);
else
return Py_CompileString(str, filename, start);
if (supplied_flags & ~(PyCF_MASK | PyCF_MASK_OBSOLETE)) {
PyErr_SetString(PyExc_ValueError,
"compile(): unrecognised flags");
return NULL;
}
/* XXX Warn if (supplied_flags & PyCF_MASK_OBSOLETE) != 0? */
cf.cf_flags = supplied_flags;
if (!dont_inherit) {
PyEval_MergeCompilerFlags(&cf);
}
return Py_CompileStringFlags(str, filename, start, &cf);
}
static char compile_doc[] =
"compile(source, filename, mode) -> code object\n\
"compile(source, filename, mode[, flags[, dont_inherit]]) -> code object\n\
\n\
Compile the source string (a Python module, statement or expression)\n\
into a code object that can be executed by the exec statement or eval().\n\
The filename will be used for run-time error messages.\n\
The mode must be 'exec' to compile a module, 'single' to compile a\n\
single (interactive) statement, or 'eval' to compile an expression.";
single (interactive) statement, or 'eval' to compile an expression.\n\
The flags argument, if present, controls which future statements influence\n\
the compilation of the code.\n\
The dont_inherit argument, if non-zero, stops the compilation inheriting\n\
the effects of any future statements in effect in the code calling\n\
compile; if absent or zero these statements do influence the compilation,\n\
in addition to any features explicitly specified.";
static PyObject *