public void Visit(PyAst.ForStatement node) { AppendLineWithIndentation($"for {Visit(node.Left)} in {Visit(node.List)}:"); using (new Indenter(this)) { Visit(node.Body); } }
// ForStatement public override bool Walk(ForStatement node) { forAnalyzer.Analyze(node); return true; }
// ForStatement public bool Walk(ForStatement node) { return Process(node); }
//for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] private ForStatement ParseForStmt() { Eat(TokenKind.KeywordFor); Location start = GetStart(); List<Expression> l = ParseExprList(); //TokenKind.KeywordIn); // expr list is something like: // () // a // a,b // a,b,c // we either want just () or a or we want (a,b) and (a,b,c) // so we can do tupleExpr.EmitSet() or loneExpr.EmitSet() Expression lhs = MakeTupleOrExpr(l, false); Eat(TokenKind.KeywordIn); Expression list = ParseTestListAsExpr(false); Location header = GetEnd(); Statement body = ParseSuite(); Statement else_ = null; if (MaybeEat(TokenKind.KeywordElse)) { else_ = ParseSuite(); } ForStatement ret = new ForStatement(lhs, list, body, else_); ret.Header = header; ret.SetLoc(GetExternal(), start, GetEnd()); return ret; }
//for_stmt: 'for' target_list 'in' expression_list ':' suite ['else' ':' suite] private ForStatement ParseForStmt() { Eat(TokenKind.KeywordFor); var start = GetStart(); bool trailingComma; List<Expression> l = ParseTargetList(out trailingComma); // expr list is something like: // () // a // a,b // a,b,c // we either want just () or a or we want (a,b) and (a,b,c) // so we can do tupleExpr.EmitSet() or loneExpr.EmitSet() Expression lhs = MakeTupleOrExpr(l, trailingComma); Eat(TokenKind.KeywordIn); Expression list = ParseTestListAsExpr(); var header = GetEnd(); Statement body = ParseLoopSuite(); Statement else_ = null; if (MaybeEat(TokenKind.KeywordElse)) { else_ = ParseSuite(); } ForStatement ret = new ForStatement(lhs, list, body, else_); ret.HeaderIndex = header; ret.SetLoc(_globalParent, start, GetEnd()); return ret; }
internal For(ForStatement stmt) : this() { _target = Convert(stmt.Left, Store.Instance); _iter = Convert(stmt.List); _body = ConvertStatements(stmt.Body); _orelse = ConvertStatements(stmt.Else, true); }
public override bool Walk(ForStatement node) { loopCount++; return true; }
public override void PostWalk(ForStatement node) { string elseSt = node.Else != null ? Content() : null; string body = Content(); string list = Content(); string variable = Content(); string listVar = String.Format(LIST, variable); string cntVar = String.Format(COUNTER, variable); StringBuilder sb = new StringBuilder(); sb.Append(Indent()); sb.AppendFormat("var {0} = _.toArray({1});", listVar, list); sb.AppendLine(); sb.Append(Indent()); sb.AppendFormat("for (var {0} = 0; {0} < {1}.length; {0}++) {{", cntVar, listVar ); sb.AppendLine(); sb.Append(Indent(indent + 1)); sb.AppendFormat("var {0} = {1}[{2}];", variable, listVar, cntVar); sb.AppendLine(); sb.AppendLine(); sb.AppendLine(body); if (elseSt != null) { sb.AppendLine(); sb.Append(Indent(indent + 1)); sb.AppendFormat("if ({0} == {1}.length - 1) {{", cntVar, listVar); sb.AppendLine(); sb.AppendLine(elseSt); sb.Append(Indent(indent + 1)); sb.AppendLine("}"); } sb.Append(Indent()); sb.AppendLine("}"); Content(sb.ToString()); CommonPostWalk(node, true); }
public override bool Walk(ForStatement node) { Emit(node); return false; }
public override bool Walk(ForStatement node) { return true; }
public virtual void PostWalk(ForStatement node) { }
// ForStatement public virtual bool Walk(ForStatement node) { return true; }
// ForStmt public override bool Walk(ForStatement node) { node.Left.Walk(define); // Add locals Debug.Assert(current != null); current.TempsCount += ForStatement.LocalSlots; return true; }
// Python 2.5 -> "for" expression_list "in" or_test private ForStatement ParseGenExprFor() { Location start = GetStart(); Eat(TokenKind.KeywordFor); List<Expression> l = ParseExprList(); Expression lhs = MakeTupleOrExpr(l, false); Eat(TokenKind.KeywordIn); Expression test = null; if (Options.Python25 == true) { test = ParseOrTest(); } else { test = ParseTest(); } ForStatement gef = new ForStatement(lhs, test, null, null); Location end = GetEnd(); gef.SetLoc(GetExternal(), start, end); gef.Header = end; return gef; }
public void Analyze(ForStatement fs) { forStatement = fs; forStatement.Left.Walk(this); }
public override bool Walk(ForStatement node) { CommonWalk(node); return true; }
public ForDefinition(ForStatement forStatement) { this.forStatement = forStatement; }
public override void PostWalk(ForStatement node) { loopCount--; }
// ForStmt public override bool Walk(ForStatement node) { // Walk the expression node.List.Walk(this); BitArray opte = new BitArray(_bits); BitArray exit = new BitArray(_bits.Length, true); PushLoop(exit); // Define the lhs node.Left.Walk(_fdef); // Walk the body node.Body.Walk(this); PopLoop(); _bits.And(exit); if (node.Else != null) { // Flow the else BitArray save = _bits; _bits = opte; node.Else.Walk(this); // Restore the bits _bits = save; } // Intersect _bits.And(opte); return false; }
// ForEachStatement public override bool Walk(ForStatement node) { node.Parent = _currentScope; if (_currentScope is FunctionDefinition) { _currentScope.ShouldInterpret = false; } // we only push the loop for the body of the loop // so we need to walk the for statement ourselves node.Left.Walk(_define); if (node.Left != null) { node.Left.Walk(this); } if (node.List != null) { node.List.Walk(this); } PushLoop(node); if (node.Body != null) { node.Body.Walk(this); } PopLoop(); if (node.Else != null) { node.Else.Walk(this); } return false; }
// ForEachStatement public override bool Walk(ForStatement node) { node.Left.Walk(_define); // Add locals return true; }
public override bool Walk(ForStatement node) { _iterators.Add(new ComprehensionFor(node.Left, node.List)); node.Body.Walk(this); return false; }
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); }
// "for" target_list "in" or_test private ForStatement ParseGenExprFor() { var start = GetStart(); Eat(TokenKind.KeywordFor); bool trailingComma; List<Expression> l = ParseTargetList(out trailingComma); Expression lhs = MakeTupleOrExpr(l, trailingComma); Eat(TokenKind.KeywordIn); Expression expr = null; expr = ParseOrTest(); ForStatement gef = new ForStatement(lhs, expr, null, null); var end = GetEnd(); gef.SetLoc(_globalParent, start, end); gef.HeaderIndex = end; return gef; }
public void PostWalk(ForStatement node) { PostProcess(node); }