internal Expr(ExpressionStatement stmt)
: this() {
_value = Convert(stmt.Expression);
}
public override bool Walk(ExpressionStatement node)
{
CommonWalk(node);
return true;
}
public override void PostWalk(ExpressionStatement node)
{
CommonPostWalk(node);
}
// ExpressionStatement
public bool Walk(ExpressionStatement node)
{
return Process(node);
}
// expr_stmt: expression_list
// expression_list: expression ( "," expression )* [","]
// assignment_stmt: (target_list "=")+ (expression_list | yield_expression)
// augmented_assignment_stmt ::= target augop (expression_list | yield_expression)
// augop: '+=' | '-=' | '*=' | '/=' | '%=' | '**=' | '>>=' | '<<=' | '&=' | '^=' | '|=' | '//='
private Statement ParseExprStmt() {
Expression ret = ParseTestListAsExpr(false);
if (ret is ErrorExpression) {
NextToken();
}
if (PeekToken(TokenKind.Assign)) {
return FinishAssignments(ret);
} else {
PythonOperator op = GetAssignOperator(PeekToken());
if (op != PythonOperator.None) {
NextToken();
Expression rhs;
if (MaybeEat(TokenKind.KeywordYield)) {
rhs = ParseYieldExpression();
} else {
rhs = ParseTestListAsExpr(false);
}
if (ret is ListExpression || ret is TupleExpression) {
ReportSyntaxError(ret.Start, ret.End, "illegal expression for augmented assignment");
}
AugmentedAssignStatement aug = new AugmentedAssignStatement(op, ret, rhs);
aug.SetLoc(ret.Start, GetEnd());
return aug;
} else {
Statement stmt = new ExpressionStatement(ret);
stmt.SetLoc(ret.Span);
return stmt;
}
}
}
private Statement ParseYieldStmt() {
// For yield statements, continue to enforce that it's currently in a function.
// This gives us better syntax error reporting for yield-statements than for yield-expressions.
FunctionDefinition current = CurrentFunction;
if (current == null) {
ReportSyntaxError(IronPython.Resources.MisplacedYield);
}
_isGenerator = true;
if (_returnWithValue) {
ReportSyntaxError("'return' with argument inside generator");
}
Eat(TokenKind.KeywordYield);
// See Pep 342: a yield statement is now just an expression statement around a yield expression.
Expression e = ParseYieldExpression();
Debug.Assert(e != null); // caller already verified we have a yield.
Statement s = new ExpressionStatement(e);
s.SetLoc(_globalParent, e.IndexSpan);
return s;
}
public override bool Walk(ExpressionStatement node)
{
writer.WriteLine("Expr");
return base.Walk(node);
}
public override void PostWalk(ExpressionStatement node)
{
base.PostWalk(node);
Console.WriteLine("EXPRESSION:" + node.Expression);
}
internal override AstExpression Revert()
{
Statement stmt = new ExpressionStatement(new YieldExpression(expr.Revert(elt)));
int comprehensionIdx = generators.Count - 1;
AstExpression list;
do {
comprehension c = (comprehension)generators[comprehensionIdx];
if (c.ifs != null && c.ifs.Count != 0) {
int ifIdx = c.ifs.Count - 1;
while (ifIdx >= 0) {
IfStatementTest ist = new IfStatementTest(expr.Revert(c.ifs[ifIdx]), stmt);
stmt = new IfStatement(new IfStatementTest[] { ist }, null);
ifIdx--;
}
}
list = expr.Revert(c.iter);
stmt = new ForStatement(expr.Revert(c.target), list, stmt, null);
comprehensionIdx--;
} while (comprehensionIdx >= 0);
((ForStatement)stmt).List = new NameExpression(generatorFnArgName);
Parameter parameter = new Parameter(generatorFnArgName, 0);
FunctionDefinition functionDefinition = new FunctionDefinition(generatorFnName, new Parameter[] { parameter }, stmt);
functionDefinition.IsGenerator = true;
return new GeneratorExpression(functionDefinition, list);
}
public virtual void PostWalk(ExpressionStatement node)
{
}
public override bool Walk(ExpressionStatement node)
{
Emit(node); return false;
}
// ExpressionStatement
public virtual bool Walk(ExpressionStatement node)
{
return true;
}
//expr_stmt: testlist (augassign testlist | ('=' testlist)*)
//augassign: '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' | '<<=' | '>>=' | '**=' | '//='
private Statement ParseExprStmt()
{
Expression lhs = ParseTestListAsExpr(false);
if (MaybeEat(TokenKind.Assign)) {
List<Expression> l = new List<Expression>();
l.Add(lhs);
do {
Expression e = ParseTestListAsExpr(false);
l.Add(e);
} while (MaybeEat(TokenKind.Assign));
int last = l.Count - 1;
Expression rhs = (Expression)l[last];
l.RemoveAt(last);
Expression[] lhss = l.ToArray();
//We check for legal assignment targets during code generation rather than parsing
Statement ret = new AssignStatement(lhss, rhs);
ret.SetLoc(GetExternal(), lhs.Start, GetEnd());
return ret;
} else {
BinaryOperator op = GetAssignOp(PeekToken());
if (op == null) {
Statement ret = new ExpressionStatement(lhs);
ret.SetLoc(GetExternal(), lhs.Start, GetEnd());
return ret;
} else {
NextToken();
Expression rhs = ParseTestListAsExpr(false);
Statement ret = new AugAssignStatement(op, lhs, rhs);
ret.SetLoc(GetExternal(), lhs.Start, GetEnd());
return ret;
}
}
}
public void Visit(PyAst.ExpressionStatement node) => AppendLineWithIndentation(Visit(node.Expression));
private Expression ParseLambdaHelperEnd(FunctionDefinition func, Expression expr) {
// Pep 342 in Python 2.5 allows Yield Expressions, which can occur inside a Lambda body.
// In this case, the lambda is a generator and will yield it's final result instead of just return it.
Statement body;
if (func.IsGenerator) {
YieldExpression y = new YieldExpression(expr);
y.SetLoc(_globalParent, expr.IndexSpan);
body = new ExpressionStatement(y);
} else {
body = new ReturnStatement(expr);
}
body.SetLoc(_globalParent, expr.StartIndex, expr.EndIndex);
FunctionDefinition func2 = PopFunction();
System.Diagnostics.Debug.Assert(func == func2);
func.Body = body;
func.EndIndex = GetEnd();
LambdaExpression ret = new LambdaExpression(func);
func.SetLoc(_globalParent, func.IndexSpan);
ret.SetLoc(_globalParent, func.IndexSpan);
return ret;
}
internal override AstExpression Revert()
{
Statement newBody;
AstExpression exp = expr.Revert(body);
if (!_containsYield)
newBody = new ReturnStatement(exp);
else
newBody = new ExpressionStatement(exp);
Parameter[] para = args.Revert();
FunctionDefinition fd = new FunctionDefinition(null, para, newBody);
fd.IsGenerator = _containsYield;
_containsYield = false;
return new LambdaExpression(fd);
}
// genexpr_for ::= "for" target_list "in" or_test [genexpr_iter]
// genexpr_iter ::= (genexpr_for | genexpr_if) *
//
// "for" has NOT been eaten before entering this method
private Expression ParseGeneratorExpression(Expression expr) {
ForStatement root = ParseGenExprFor();
Statement current = root;
for (; ; ) {
if (PeekToken(Tokens.KeywordForToken)) {
current = NestGenExpr(current, ParseGenExprFor());
} else if (PeekToken(Tokens.KeywordIfToken)) {
current = NestGenExpr(current, ParseGenExprIf());
} else {
// Generator Expressions have an implicit function definition and yield around their expression.
// (x for i in R)
// becomes:
// def f():
// for i in R: yield (x)
ExpressionStatement ys = new ExpressionStatement(new YieldExpression(expr));
ys.Expression.SetLoc(_globalParent, expr.IndexSpan);
ys.SetLoc(_globalParent, expr.IndexSpan);
NestGenExpr(current, ys);
break;
}
}
// We pass the outermost iterable in as a parameter because Python semantics
// say that this one piece is computed at definition time rather than iteration time
const string fname = "<genexpr>";
Parameter parameter = new Parameter("__gen_$_parm__", 0);
FunctionDefinition func = new FunctionDefinition(fname, new Parameter[] { parameter }, root);
func.IsGenerator = true;
func.SetLoc(_globalParent, root.StartIndex, GetEnd());
func.HeaderIndex = root.EndIndex;
// Transform the root "for" statement
Expression outermost = root.List;
NameExpression ne = new NameExpression("__gen_$_parm__");
ne.SetLoc(_globalParent, outermost.IndexSpan);
root.List = ne;
GeneratorExpression ret = new GeneratorExpression(func, outermost);
ret.SetLoc(_globalParent, expr.StartIndex, GetEnd());
return ret;
}
public void PostWalk(ExpressionStatement node)
{
PostProcess(node);
}
// expr_stmt: expression_list
// expression_list: expression ( "," expression )* [","]
// assignment_stmt: (target_list "=")+ (expression_list | yield_expression)
// augmented_assignment_stmt ::= target augop (expression_list | yield_expression)
// augop: '+=' | '-=' | '*=' | '/=' | '%=' | '**=' | '>>=' | '<<=' | '&=' | '^=' | '|=' | '//='
private Statement ParseExprStmt() {
Expression ret = ParseTestListAsExpr();
if (ret is ErrorExpression) {
NextToken();
}
if (PeekToken(TokenKind.Assign)) {
return FinishAssignments(ret);
} else {
PythonOperator op = GetAssignOperator(PeekToken());
if (op != PythonOperator.None) {
NextToken();
Expression rhs;
if (MaybeEat(TokenKind.KeywordYield)) {
rhs = ParseYieldExpression();
} else {
rhs = ParseTestListAsExpr();
}
string assignError = ret.CheckAugmentedAssign();
if (assignError != null) {
ReportSyntaxError(assignError);
}
AugmentedAssignStatement aug = new AugmentedAssignStatement(op, ret, rhs);
aug.SetLoc(_globalParent, ret.StartIndex, GetEnd());
return aug;
} else {
Statement stmt = new ExpressionStatement(ret);
stmt.SetLoc(_globalParent, ret.IndexSpan);
return stmt;
}
}
}
// ExpressionStatement
public override bool Walk(ExpressionStatement node)
{
node.Parent = _currentScope;
return(base.Walk(node));
}
