public override void OnForStatement(ForStatement node) { if (node.LexicalInfo.Line <= resolver.CaretLine && GetEndSourceLocation(node).Line >= resolver.CaretLine - 1) { foreach (Declaration decl in node.Declarations) { IterationDeclarationFound(decl.Name, decl.Type, node.Iterator, node.LexicalInfo); } } base.OnForStatement(node); }
public object VisitForeachStatement(ForeachStatement foreachStatement, object data) { B.ForStatement fs = new B.ForStatement(GetLexicalInfo(foreachStatement)); fs.EndSourceLocation = GetLocation(foreachStatement.EndLocation); fs.Iterator = ConvertExpression(foreachStatement.Expression); fs.Declarations.Add(new B.Declaration(foreachStatement.VariableName, ConvertTypeReference(foreachStatement.TypeReference))); fs.Block = ConvertBlock(foreachStatement.EmbeddedStatement); return(fs); }
public override void LeaveForStatement(ForStatement node) { //do not optimize local-reusing loops (BOO-1111) //TODO: optimize anyway (modify end value to match generator model vs optimized model) if (node.Declarations.Count == 1 && null != AstUtil.GetLocalByName(_currentMethod, node.Declarations[0].Name)) return; CheckForItemInRangeLoop(node); CheckForItemInArrayLoop(node); }
public object VisitForNextStatement(ForNextStatement forNextStatement, object data) { if (forNextStatement.TypeReference.IsNull) { return(MakeManualLoop(forNextStatement)); } B.ForStatement fs = new B.ForStatement(GetLexicalInfo(forNextStatement)); fs.Block = ConvertBlock(forNextStatement.EmbeddedStatement); fs.Declarations.Add(new B.Declaration(forNextStatement.VariableName, null)); B.Expression start = ConvertExpression(forNextStatement.Start); Expression end = forNextStatement.End; if (forNextStatement.Step == null || forNextStatement.Step.IsNull) { // range only goes to end - 1, so increment end end = Expression.AddInteger(end, 1); fs.Iterator = MakeMethodCall("range", start, ConvertExpression(end)); } else { PrimitiveExpression stepPE = forNextStatement.Step as PrimitiveExpression; if (stepPE == null || !(stepPE.Value is int)) { AddError(forNextStatement, "Step must be an integer literal"); } else { if ((int)stepPE.Value < 0) { end = Expression.AddInteger(end, -1); } else { end = Expression.AddInteger(end, 1); } } fs.Iterator = MakeMethodCall("range", start, ConvertExpression(end), ConvertExpression(forNextStatement.Step)); } return(fs); }
public Statement for_in(Block container) { Statement stmt = null; try { Declaration declaration2; Block block; int num = this.LA(1); switch (num) { case 12: case 0x10: case 0x21: case 0x3b: { IToken token = this.identifier(); if (base.inputState.guessing == 0) { Declaration declaration; Declaration declaration1 = declaration = new Declaration(ToLexicalInfo(token)); declaration.set_Name(token.getText()); declaration2 = declaration; } break; } default: if (num != 0x2d) { throw new NoViableAltException(this.LT(1), this.getFilename()); } declaration2 = this.declaration(); if (base.inputState.guessing == 0) { DeclarationAnnotations.ForceNewVariable(declaration2); } break; } this.match(0x18); Expression expression = this.expression(); if (base.inputState.guessing == 0) { ForStatement statement2; ForStatement statement1 = statement2 = new ForStatement(); statement2.set_Iterator(expression); ForStatement statement3 = statement2; statement3.get_Declarations().Add(declaration2); block = statement3.get_Block(); stmt = statement3; container.Add(stmt); this.EnterLoop(stmt); } this.match(0x40); this.compound_or_single_stmt(block); if (base.inputState.guessing == 0) { this.LeaveLoop(stmt); } } catch (RecognitionException exception) { if (base.inputState.guessing != 0) { throw; } this.reportError(exception); this.recover(exception, tokenSet_15_); return stmt; } return stmt; }
public object VisitForNextStatement(ForNextStatement forNextStatement, object data) { if (forNextStatement.TypeReference.IsNull) return MakeManualLoop(forNextStatement); B.ForStatement fs = new B.ForStatement(GetLexicalInfo(forNextStatement)); fs.Block = ConvertBlock(forNextStatement.EmbeddedStatement); fs.Declarations.Add(new B.Declaration(forNextStatement.VariableName, null)); B.Expression start = ConvertExpression(forNextStatement.Start); Expression end = forNextStatement.End; if (forNextStatement.Step == null || forNextStatement.Step.IsNull) { // range only goes to end - 1, so increment end end = Expression.AddInteger(end, 1); fs.Iterator = MakeMethodCall("range", start, ConvertExpression(end)); } else { PrimitiveExpression stepPE = forNextStatement.Step as PrimitiveExpression; if (stepPE == null || !(stepPE.Value is int)) { AddError(forNextStatement, "Step must be an integer literal"); } else { if ((int)stepPE.Value < 0) end = Expression.AddInteger(end, -1); else end = Expression.AddInteger(end, 1); } fs.Iterator = MakeMethodCall("range", start, ConvertExpression(end), ConvertExpression(forNextStatement.Step)); } return fs; }
public override void OnForStatement(ForStatement node) { base.OnForStatement(node); }
public override void OnExtendedGeneratorExpression(ExtendedGeneratorExpression node) { BlockExpression block = new BlockExpression(node.LexicalInfo); Block body = block.Body; Expression e = node.Items[0].Expression; foreach (GeneratorExpression ge in node.Items) { ForStatement fs = new ForStatement(ge.LexicalInfo); fs.Iterator = ge.Iterator; fs.Declarations = ge.Declarations; body.Add(fs); if (null == ge.Filter) { body = fs.Block; } else { fs.Block.Add( NormalizeStatementModifiers.MapStatementModifier(ge.Filter, out body)); } } body.Add(new YieldStatement(e.LexicalInfo, e)); MethodInvocationExpression mie = new MethodInvocationExpression(node.LexicalInfo); mie.Target = block; Node parentNode = node.ParentNode; bool isGenerator = AstUtil.IsListMultiGenerator(parentNode); parentNode.Replace(node, mie); mie.Accept(this); if (isGenerator) { parentNode.ParentNode.Replace( parentNode, CodeBuilder.CreateConstructorInvocation( TypeSystemServices.Map(ProcessGenerators.List_IEnumerableConstructor), mie)); } }
public void TransformIteration(ForStatement node) { string[] textArray1 = new string[] { "iterator" }; InternalLocal iteratorVariable = this.get_CodeBuilder().DeclareLocal(this.get_CurrentMethod(), base._context.GetUniqueName(textArray1), this.get_TypeSystemServices().IEnumeratorType); iteratorVariable.set_IsUsed(true); Block block = new Block(node.get_LexicalInfo()); block.Add(this.get_CodeBuilder().CreateAssignment(node.get_LexicalInfo(), this.get_CodeBuilder().CreateReference(iteratorVariable), node.get_Iterator())); WhileStatement statement = new WhileStatement(node.get_LexicalInfo()); statement.set_Condition(this.get_CodeBuilder().CreateMethodInvocation(this.get_CodeBuilder().CreateReference(iteratorVariable), this.IEnumerator_MoveNext)); MethodInvocationExpression expression = this.get_CodeBuilder().CreateMethodInvocation(this.get_CodeBuilder().CreateReference(iteratorVariable), this.IEnumerator_get_Current); InternalLocal entity = TypeSystemServices.GetEntity(node.get_Declarations().get_Item(0)); statement.get_Block().Add(this.get_CodeBuilder().CreateAssignment(node.get_LexicalInfo(), this.get_CodeBuilder().CreateReference(entity), expression)); statement.get_Block().Add(node.get_Block()); new LoopVariableUpdater(this, base._context, iteratorVariable, entity).Visit(node); block.Add(statement); node.get_ParentNode().Replace(node, block); }
public override void OnForStatement(ForStatement fs) { WriteIndented(); WriteKeyword("for "); for (int i=0; i<fs.Declarations.Count; ++i) { if (i > 0) { Write(", "); } Visit(fs.Declarations[i]); } WriteKeyword(" in "); Visit(fs.Iterator); WriteLine(":"); WriteBlock(fs.Block); if(fs.OrBlock != null) { WriteIndented(); WriteKeyword("or:"); WriteLine(); WriteBlock(fs.OrBlock); } if(fs.ThenBlock != null) { WriteIndented(); WriteKeyword("then:"); WriteLine(); WriteBlock(fs.ThenBlock); } }
protected void VisitForStatementBlock(ForStatement node) { EnterForNamespace(node); Visit(node.Block); Visit(node.OrBlock); Visit(node.ThenBlock); LeaveNamespace(); }
override public object Clone() { ForStatement clone = new ForStatement(); clone._lexicalInfo = _lexicalInfo; clone._endSourceLocation = _endSourceLocation; clone._documentation = _documentation; clone._isSynthetic = _isSynthetic; clone._entity = _entity; if (_annotations != null) clone._annotations = (Hashtable)_annotations.Clone(); if (null != _modifier) { clone._modifier = _modifier.Clone() as StatementModifier; clone._modifier.InitializeParent(clone); } if (null != _declarations) { clone._declarations = _declarations.Clone() as DeclarationCollection; clone._declarations.InitializeParent(clone); } if (null != _iterator) { clone._iterator = _iterator.Clone() as Expression; clone._iterator.InitializeParent(clone); } if (null != _block) { clone._block = _block.Clone() as Block; clone._block.InitializeParent(clone); } if (null != _orBlock) { clone._orBlock = _orBlock.Clone() as Block; clone._orBlock.InitializeParent(clone); } if (null != _thenBlock) { clone._thenBlock = _thenBlock.Clone() as Block; clone._thenBlock.InitializeParent(clone); } return clone; }
public override void OnForStatement(ForStatement node) { VisitLoop(node.Block); }
private LabelStatement CreateUpdateLabel(ForStatement node) { return new LabelStatement(LexicalInfo.Empty, "$label$" + _context.AllocIndex()); }
public override void LeaveForStatement(ForStatement node) { CheckForItemInRangeLoop(node); CheckForItemInArrayLoop(node); }
override public void LeaveForStatement(ForStatement node) { _iteratorNode = node.Iterator; CurrentEnumeratorType = GetExpressionType(node.Iterator); if (null == CurrentBestEnumeratorType) return; //error DeclarationCollection declarations = node.Declarations; Block body = new Block(node.LexicalInfo); InternalLocal iterator = CodeBuilder.DeclareLocal(_current, Context.GetUniqueName("iterator"), CurrentBestEnumeratorType); if (CurrentBestEnumeratorType == CurrentEnumeratorType) { //$iterator = <node.Iterator> body.Add( CodeBuilder.CreateAssignment( node.LexicalInfo, CodeBuilder.CreateReference(iterator), node.Iterator)); } else { //$iterator = <node.Iterator>.GetEnumerator() body.Add( CodeBuilder.CreateAssignment( node.LexicalInfo, CodeBuilder.CreateReference(iterator), CodeBuilder.CreateMethodInvocation(node.Iterator, CurrentBestGetEnumerator))); } // while __iterator.MoveNext(): if (null == CurrentBestMoveNext) return; //error WhileStatement ws = new WhileStatement(node.LexicalInfo); ws.Condition = CodeBuilder.CreateMethodInvocation( CodeBuilder.CreateReference(iterator), CurrentBestMoveNext); if (null == CurrentBestGetCurrent) return; //error Expression current = CodeBuilder.CreateMethodInvocation( CodeBuilder.CreateReference(iterator), CurrentBestGetCurrent); if (1 == declarations.Count) { // item = __iterator.Current ws.Block.Add( CodeBuilder.CreateAssignment( node.LexicalInfo, CodeBuilder.CreateReference((InternalLocal)declarations[0].Entity), current)); } else { UnpackExpression(ws.Block, CodeBuilder.CreateCast( CurrentEnumeratorItemType, current), node.Declarations); } ws.Block.Add(node.Block); ws.OrBlock = node.OrBlock; ws.ThenBlock = node.ThenBlock; // try: // while... // ensure: // d = iterator as IDisposable // d.Dispose() unless d is null if (IsAssignableFrom(TypeSystemServices.IDisposableType, CurrentBestEnumeratorType)) { TryStatement tryStatement = new TryStatement(); tryStatement.ProtectedBlock.Add(ws); tryStatement.EnsureBlock = new Block(); CastExpression castExpression = new CastExpression(); castExpression.Type = CodeBuilder.CreateTypeReference(TypeSystemServices.IDisposableType); castExpression.Target = CodeBuilder.CreateReference(iterator); castExpression.ExpressionType = TypeSystemServices.IDisposableType; tryStatement.EnsureBlock.Add( CodeBuilder.CreateMethodInvocation(castExpression, IDisposable_Dispose)); body.Add(tryStatement); } else { body.Add(ws); } ReplaceCurrentNode(body); }
protected override Statement ExpandImpl(MacroStatement macro){ if (macro.Arguments.Count == 0){ throw new Exception("need at least one IEnumerable parameter"); } var result = new Block(); Expression src = macro.Arguments[0]; var idx = new ReferenceExpression("_idx"); Expression item = new ReferenceExpression("i"); var col = new ReferenceExpression("current_collection"); if (src is BinaryExpression){ item = ((BinaryExpression) src).Left; src = ((BinaryExpression) src).Right; } if (macro.Arguments.Count > 1){ idx = (ReferenceExpression) macro.Arguments[1]; } string prefix = macro.get<string>("_prefix") ?? ""; string suffix = macro.get<string>("_suffix") ?? ""; Func<string, MacroStatement> findmacro = s =>{ var r = macro.get<Node>(s); if (null == r){ return null; } if (!(r is MacroStatement)){ var m = new MacroStatement("stub"); m.Body = new Block().add(r); r = m; } return (MacroStatement) r; }; Func<MacroStatement, Block> extract = m =>{ if (null == m){ return null; } if (m.Body != null && !m.Body.IsEmpty){ if (m.Body.Statements.Count == 1){ if (m.Body.Statements[0] is ExpressionStatement){ Expression _ex = ((ExpressionStatement) m.Body.Statements[0]). Expression; if (_ex is LiteralExpression || !_ex.ToCodeString().ToLower().StartsWith("out")){ return new Block().add(_ex.writeOut()); } } } return m.Body; } if (m.Arguments.Count == 0){ return null; } var r = new Block(); if (!(m.Arguments[0] is MethodInvocationExpression)){ r.Add(BrailBuildingHelper.WriteOut(m.Arguments[0])); } else{ r.Add(m.Arguments[0]); } return r; }; MacroStatement beforeall_macro = findmacro("beforeall"); MacroStatement onitem_macro = findmacro("onitem") ?? macro; MacroStatement onerror_macro = findmacro("onerror"); ; MacroStatement between_macro = findmacro("between"); ; MacroStatement afterall_macro = findmacro("afterall"); ; MacroStatement onempty_macro = findmacro("onempty"); ; MacroStatement beforeeach_macro = findmacro("beforeeach"); ; MacroStatement aftereach_macro = findmacro("aftereach"); MacroStatement prepare_macro = findmacro("prepare"); ; Block beforeall = extract(beforeall_macro); Block onitem = extractMainItemBlock(macro, extract, onitem_macro, item, prefix, suffix); Block onerror = extract(onerror_macro); Block between = extract(between_macro); Block afterall = extract(afterall_macro); Block onempty = null; bool proceed_on_empty = false; if (onempty_macro != null && onempty_macro.Arguments.Count != 0 && onempty_macro.Arguments[0].ToCodeString() == "proceed"){ proceed_on_empty = true; } else{ onempty = extract(onempty_macro); } Block beforeeach = extract(beforeeach_macro); Block aftereach = extract(aftereach_macro); // _idx = 0 Statement betweener = getBetweener(idx, between); result.Add(col.assign(new MethodInvocationExpression(new ReferenceExpression("_wrapcollection"), src))); result.Add(new ReferenceExpression("___proceed").assign(new BoolLiteralExpression(proceed_on_empty))); var mainblock = new Block(); mainblock.Add(idx.assign(0)); mainblock.Add(new IfStatement( new BinaryExpression(BinaryOperatorType.Equality, new NullLiteralExpression(), col), new Block().add(new BinaryExpression(BinaryOperatorType.Assign, col, new MethodInvocationExpression( new ReferenceExpression("_wrapcollection"), new ArrayLiteralExpression()))), null )); if (beforeall != null){ mainblock.Add(beforeall); } var maincycle = new ForStatement(); maincycle.Iterator = col; string declname = item.ToCodeString(); TypeReference decltype = null; if (item is TryCastExpression){ declname = ((TryCastExpression) item).Target.ToCodeString(); decltype = ((TryCastExpression) item).Type; } maincycle.Declarations.Add(new Declaration(maincycle.LexicalInfo, declname, decltype)); maincycle.Block = new Block(); maincycle.ThenBlock = afterall; if (betweener != null){ maincycle.Block.Add(betweener); } if (null != prepare_macro){ maincycle.Block.Add(prepare_macro.Body); } if (null != beforeeach){ maincycle.Block.Add(beforeeach); } if (onerror == null){ maincycle.Block.Add(onitem); } else{ var trycatch = new TryStatement(); var exchandler = new ExceptionHandler(); exchandler.Block = onerror; exchandler.Declaration = new Declaration("_ex", new SimpleTypeReference("System.Exception")); trycatch.ProtectedBlock = onitem; trycatch.ExceptionHandlers.Add(exchandler); maincycle.Block.Add(trycatch); } if (null != aftereach){ maincycle.Block.Add(aftereach); } maincycle.Block.Add(new UnaryExpression(UnaryOperatorType.Increment, idx)); mainblock.Add(maincycle); result.Add( new IfStatement( getMainCondition(col), mainblock, onempty ) ); // if null!=items and (items as IEnumerable).Cast[of System.Object]().Count() != 0: return result; }
//throws RecognitionException, TokenStreamException protected ForStatement for_stmt() { ForStatement fs; IToken f = null; IToken or = null; IToken et = null; fs = null; Expression iterator = null; DeclarationCollection declarations = null; Block body = null; try { // for error handling f = LT(1); match(FOR); if (0==inputState.guessing) { fs = new ForStatement(ToLexicalInfo(f)); declarations = fs.Declarations; body = fs.Block; } declaration_list(declarations); match(IN); iterator=array_or_expression(); if (0==inputState.guessing) { fs.Iterator = iterator; } compound_stmt(body); { switch ( LA(1) ) { case OR: { or = LT(1); match(OR); if (0==inputState.guessing) { fs.OrBlock = new Block(ToLexicalInfo(or)); } compound_stmt(fs.OrBlock); break; } case EOF: case DEDENT: case ESEPARATOR: case BREAK: case CONTINUE: case CAST: case CHAR: case DEF: case FOR: case FALSE: case GOTO: case IF: case NULL: case RAISE: case RETURN: case SELF: case SUPER: case THEN: case TRY: case TRUE: case TYPEOF: case UNLESS: case WHILE: case YIELD: case ID: case TRIPLE_QUOTED_STRING: case DOUBLE_QUOTED_STRING: case SINGLE_QUOTED_STRING: case LBRACK: case LPAREN: case ASSEMBLY_ATTRIBUTE_BEGIN: case SPLICE_BEGIN: case DOT: case COLON: case MULTIPLY: case LBRACE: case QQ_BEGIN: case SUBTRACT: case LONG: case INCREMENT: case DECREMENT: case ONES_COMPLEMENT: case INT: case RE_LITERAL: case DOUBLE: case FLOAT: case TIMESPAN: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } { switch ( LA(1) ) { case THEN: { et = LT(1); match(THEN); if (0==inputState.guessing) { fs.ThenBlock = new Block(ToLexicalInfo(et)); } compound_stmt(fs.ThenBlock); break; } case EOF: case DEDENT: case ESEPARATOR: case BREAK: case CONTINUE: case CAST: case CHAR: case DEF: case FOR: case FALSE: case GOTO: case IF: case NULL: case RAISE: case RETURN: case SELF: case SUPER: case TRY: case TRUE: case TYPEOF: case UNLESS: case WHILE: case YIELD: case ID: case TRIPLE_QUOTED_STRING: case DOUBLE_QUOTED_STRING: case SINGLE_QUOTED_STRING: case LBRACK: case LPAREN: case ASSEMBLY_ATTRIBUTE_BEGIN: case SPLICE_BEGIN: case DOT: case COLON: case MULTIPLY: case LBRACE: case QQ_BEGIN: case SUBTRACT: case LONG: case INCREMENT: case DECREMENT: case ONES_COMPLEMENT: case INT: case RE_LITERAL: case DOUBLE: case FLOAT: case TIMESPAN: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } } catch (RecognitionException ex) { if (0 == inputState.guessing) { reportError(ex); recover(ex,tokenSet_75_); } else { throw ex; } } return fs; }
override public void OnForStatement(ForStatement node) { VisitLoop(node.Block); Visit(node.OrBlock); Visit(node.ThenBlock); }
public override void OnForStatement(ForStatement node) { NotImplemented("ForStatement"); }
public override void OnForStatement(ForStatement node) { }
public object VisitForeachStatement(ForeachStatement foreachStatement, object data) { B.ForStatement fs = new B.ForStatement(GetLexicalInfo(foreachStatement)); fs.EndSourceLocation = GetLocation(foreachStatement.EndLocation); fs.Iterator = ConvertExpression(foreachStatement.Expression); fs.Declarations.Add(new B.Declaration(foreachStatement.VariableName, ConvertTypeReference(foreachStatement.TypeReference))); fs.Block = ConvertBlock(foreachStatement.EmbeddedStatement); return fs; }
public override void OnForStatement(ForStatement node) { this.OnLoopBody(node.get_Block()); }
/// <summary> /// Optimize the <c>for item in array</c> construct /// </summary> /// <param name="node">the for statement to check</param> private void CheckForItemInArrayLoop(ForStatement node) { var enumeratorType = GetExpressionType(node.Iterator) as IArrayType; if (enumeratorType == null || enumeratorType.Rank > 1) return; IType elementType = enumeratorType.ElementType; if (elementType is InternalCallableType) return; Block body = new Block(node.LexicalInfo); InternalLocal indexVariable = DeclareTempLocal(TypeSystemServices.IntType); Expression indexReference = CodeBuilder.CreateReference(indexVariable); // __num = 0 body.Add( CodeBuilder.CreateAssignment( indexReference, CodeBuilder.CreateIntegerLiteral(0))); InternalLocal arrayVar = DeclareTempLocal(node.Iterator.ExpressionType); ReferenceExpression arrayRef = CodeBuilder.CreateReference(arrayVar); // __arr = <arr> body.Add( CodeBuilder.CreateAssignment( arrayRef, node.Iterator)); InternalLocal endVar = CodeBuilder.DeclareTempLocal( _currentMethod, TypeSystemServices.IntType); ReferenceExpression endRef = CodeBuilder.CreateReference(endVar); // __end = __arr.Length body.Add( CodeBuilder.CreateAssignment( node.Iterator.LexicalInfo, endRef, CodeBuilder.CreateMethodInvocation( arrayRef, Array_get_Length))); // while __num < __end: WhileStatement ws = new WhileStatement(node.LexicalInfo); ws.Condition = CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.LessThan, indexReference, endRef); if (1 == node.Declarations.Count) { ILocalEntity loopVariable = (ILocalEntity) node.Declarations[0].Entity; node.Block.ReplaceNodes( new NodePredicate(new EntityPredicate(loopVariable).Matches), CreateRawArraySlicing(arrayRef, indexReference, elementType, loopVariable.Type)); } else { // alpha, bravo, charlie = arr[__num] UnpackExpression( ws.Block, CreateRawArraySlicing(arrayRef, indexReference, elementType), node.Declarations); } // <block> ws.Block.Add(node.Block); FixContinueStatements(node, ws); // __num += 1 BinaryExpression assignment = CodeBuilder.CreateAssignment( indexReference, CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.IntType, BinaryOperatorType.Addition, indexReference, CodeBuilder.CreateIntegerLiteral(1))); AstAnnotations.MarkUnchecked(assignment); ws.Block.Add(assignment); ws.OrBlock = node.OrBlock; ws.ThenBlock = node.ThenBlock; body.Add(ws); ReplaceCurrentNode(body); }
//throws RecognitionException, TokenStreamException protected ForStatement for_stmt() { ForStatement fs; IToken f = null; IToken or = null; IToken et = null; fs = null; Expression iterator = null; DeclarationCollection declarations = null; Block body = null; Block lastBlock = null; try { // for error handling f = LT(1); match(FOR); if (0==inputState.guessing) { fs = new ForStatement(SourceLocationFactory.ToLexicalInfo(f)); declarations = fs.Declarations; lastBlock = body = fs.Block; } declaration_list(declarations); match(IN); iterator=array_or_expression(); if (0==inputState.guessing) { fs.Iterator = iterator; } begin(); block(body.Statements); { switch ( LA(1) ) { case OR: { or = LT(1); match(OR); if (0==inputState.guessing) { lastBlock = fs.OrBlock = new Block(SourceLocationFactory.ToLexicalInfo(or)); } begin(); block(fs.OrBlock.Statements); break; } case END: case THEN: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } { switch ( LA(1) ) { case THEN: { et = LT(1); match(THEN); if (0==inputState.guessing) { lastBlock = fs.ThenBlock = new Block(SourceLocationFactory.ToLexicalInfo(et)); } begin(); block(fs.ThenBlock.Statements); break; } case END: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } end(lastBlock); } catch (RecognitionException ex) { if (0 == inputState.guessing) { reportError(ex); recover(ex,tokenSet_79_); } else { throw ex; } } return fs; }
/// <summary> /// Optimize the <c>for item in range()</c> construct /// </summary> /// <param name="node">the for statement to check</param> private void CheckForItemInRangeLoop(ForStatement node) { MethodInvocationExpression mi = node.Iterator as MethodInvocationExpression; if (null == mi) return; if (!IsRangeInvocation(mi)) return; DeclarationCollection declarations = node.Declarations; if (declarations.Count != 1) return; ExpressionCollection args = mi.Arguments; Block body = new Block(node.LexicalInfo); Expression min; Expression max; Expression step; IntegerLiteralExpression mini; IntegerLiteralExpression maxi; IntegerLiteralExpression stepi; if (args.Count == 1) { mini = CodeBuilder.CreateIntegerLiteral(0); min = mini; max = args[0]; maxi = max as IntegerLiteralExpression; stepi = CodeBuilder.CreateIntegerLiteral(1); step = stepi; } else if (args.Count == 2) { min = args[0]; mini = min as IntegerLiteralExpression; max = args[1]; maxi = max as IntegerLiteralExpression; stepi = CodeBuilder.CreateIntegerLiteral(1); step = stepi; } else { min = args[0]; mini = min as IntegerLiteralExpression; max = args[1]; maxi = max as IntegerLiteralExpression; step = args[2]; stepi = step as IntegerLiteralExpression; } InternalLocal numVar = CodeBuilder.DeclareTempLocal( _currentMethod, TypeSystemServices.IntType); Expression numRef = CodeBuilder.CreateReference(numVar); // __num = <min> body.Add( CodeBuilder.CreateAssignment( numRef, min)); Expression endRef; if (null != maxi) { endRef = max; } else { InternalLocal endVar = CodeBuilder.DeclareTempLocal( _currentMethod, TypeSystemServices.IntType); endRef = CodeBuilder.CreateReference(endVar); // __end = <end> body.Add( CodeBuilder.CreateAssignment( endRef, max)); } if (args.Count == 1) { if (null != maxi) { if (maxi.Value < 0) { // raise ArgumentOutOfRangeException("max") (if <max> < 0) Statement statement = CodeBuilder.RaiseException( body.LexicalInfo, TypeSystemServices.Map(System_ArgumentOutOfRangeException_ctor), CodeBuilder.CreateStringLiteral("max")); body.Add(statement); } } else { IfStatement ifStatement = new IfStatement(body.LexicalInfo); ifStatement.TrueBlock = new Block(); // raise ArgumentOutOfRangeException("max") if __end < 0 Statement statement = CodeBuilder.RaiseException( body.LexicalInfo, TypeSystemServices.Map(System_ArgumentOutOfRangeException_ctor), CodeBuilder.CreateStringLiteral("max")); ifStatement.Condition = CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.LessThan, endRef, CodeBuilder.CreateIntegerLiteral(0)); ifStatement.TrueBlock.Add(statement); body.Add(ifStatement); } } Expression stepRef; switch (args.Count) { case 1: stepRef = CodeBuilder.CreateIntegerLiteral(1); break; case 2: if (null != mini && null != maxi) { if (maxi.Value < mini.Value) // __step = -1 stepRef = CodeBuilder.CreateIntegerLiteral(-1); else // __step = 1 stepRef = CodeBuilder.CreateIntegerLiteral(1); } else { InternalLocal stepVar = CodeBuilder.DeclareTempLocal( _currentMethod, TypeSystemServices.IntType); stepRef = CodeBuilder.CreateReference(stepVar); // __step = 1 body.Add( CodeBuilder.CreateAssignment( stepRef, CodeBuilder.CreateIntegerLiteral(1))); // __step = -1 if __end < __num IfStatement ifStatement = new IfStatement(node.LexicalInfo); ifStatement.Condition = CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.LessThan, endRef, numRef); ifStatement.TrueBlock = new Block(); ifStatement.TrueBlock.Add( CodeBuilder.CreateAssignment( stepRef, CodeBuilder.CreateIntegerLiteral(-1))); body.Add(ifStatement); } break; default: if (null != stepi) { stepRef = step; } else { InternalLocal stepVar = CodeBuilder.DeclareTempLocal( _currentMethod, TypeSystemServices.IntType); stepRef = CodeBuilder.CreateReference(stepVar); // __step = <step> body.Add( CodeBuilder.CreateAssignment( stepRef, step)); } break; } if (args.Count == 3) { Expression condition = null; bool run = false; if (null != stepi) { if (stepi.Value < 0) { if (null != maxi && null != mini) { run = maxi.Value > mini.Value; } else { condition = CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.GreaterThan, endRef, numRef); } } else { if (null != maxi && null != mini) { run = maxi.Value < mini.Value; } else { condition = CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.LessThan, endRef, numRef); } } } else { if (null != maxi && null != mini) { if (maxi.Value < mini.Value) { condition = CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.GreaterThan, stepRef, CodeBuilder.CreateIntegerLiteral(0)); } else { condition = CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.LessThan, stepRef, CodeBuilder.CreateIntegerLiteral(0)); } } else { condition = CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.Or, CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.And, CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.LessThan, stepRef, CodeBuilder.CreateIntegerLiteral(0)), CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.GreaterThan, endRef, numRef)), CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.And, CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.GreaterThan, stepRef, CodeBuilder.CreateIntegerLiteral(0)), CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.LessThan, endRef, numRef))); } } // raise ArgumentOutOfRangeException("step") if (__step < 0 and __end > __begin) or (__step > 0 and __end < __begin) Statement statement = CodeBuilder.RaiseException( body.LexicalInfo, TypeSystemServices.Map(System_ArgumentOutOfRangeException_ctor), CodeBuilder.CreateStringLiteral("step")); if (condition != null) { IfStatement ifStatement = new IfStatement(body.LexicalInfo); ifStatement.TrueBlock = new Block(); ifStatement.Condition = condition; ifStatement.TrueBlock.Add(statement); body.Add(ifStatement); } else if (run) { body.Add(statement); } // __end = __num + __step * cast(int, Math.Ceiling((__end - __num)/cast(double, __step))) if (null != stepi && null != maxi && null != mini) { int stepVal = (int) stepi.Value; int maxVal = (int) maxi.Value; int minVal = (int) mini.Value; endRef = CodeBuilder.CreateIntegerLiteral( minVal + stepVal * (int)System.Math.Ceiling((maxVal - minVal) / ((double)stepVal))); } else { Expression endBak = endRef; if (null != maxi) { InternalLocal endVar = CodeBuilder.DeclareTempLocal( _currentMethod, TypeSystemServices.IntType); endRef = CodeBuilder.CreateReference(endVar); } body.Add( CodeBuilder.CreateAssignment( endRef, CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.IntType, BinaryOperatorType.Addition, numRef, CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.IntType, BinaryOperatorType.Multiply, stepRef, CodeBuilder.CreateCast( TypeSystemServices.IntType, CodeBuilder.CreateMethodInvocation( TypeSystemServices.Map(System_Math_Ceiling), CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.DoubleType, BinaryOperatorType.Division, CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.IntType, BinaryOperatorType.Subtraction, endBak, numRef), CodeBuilder.CreateCast( TypeSystemServices.DoubleType, stepRef)))))))); } } // while __num != __end: WhileStatement ws = new WhileStatement(node.LexicalInfo); BinaryOperatorType op = BinaryOperatorType.Inequality; if (stepRef.NodeType == NodeType.IntegerLiteralExpression) { if (((IntegerLiteralExpression)stepRef).Value > 0) { op = BinaryOperatorType.LessThan; } else { op = BinaryOperatorType.GreaterThan; } } ws.Condition = CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, op, numRef, endRef); ws.Condition.LexicalInfo = node.LexicalInfo; // item = __num ws.Block.Add( CodeBuilder.CreateAssignment( CodeBuilder.CreateReference((InternalLocal)declarations[0].Entity), numRef)); Block rawBlock = new Block(); rawBlock["checked"] = false; // __num += __step rawBlock.Add( CodeBuilder.CreateAssignment( numRef, CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.IntType, BinaryOperatorType.Addition, numRef, stepRef))); ws.Block.Add(rawBlock as Statement); // <block> ws.Block.Add(node.Block); ws.OrBlock = node.OrBlock; ws.ThenBlock = node.ThenBlock; body.Add(ws); ReplaceCurrentNode(body); }
protected ForStatement for_stmt() //throws RecognitionException, TokenStreamException { ForStatement fs; IToken f = null; IToken or = null; IToken et = null; fs = null; Expression iterator = null; DeclarationCollection declarations = null; Block body = null; try { // for error handling f = LT(1); match(FOR); if (0==inputState.guessing) { fs = new ForStatement(ToLexicalInfo(f)); declarations = fs.Declarations; body = fs.Block; } declaration_list(declarations); match(IN); iterator=array_or_expression(); if (0==inputState.guessing) { fs.Iterator = iterator; } compound_stmt(body); { switch ( LA(1) ) { case OR: { or = LT(1); match(OR); if (0==inputState.guessing) { fs.OrBlock = new Block(ToLexicalInfo(or)); } compound_stmt(fs.OrBlock); break; } case EOF: case DEDENT: case ESEPARATOR: case ASSEMBLY_ATTRIBUTE_BEGIN: case MODULE_ATTRIBUTE_BEGIN: case ABSTRACT: case BREAK: case CONTINUE: case CALLABLE: case CAST: case CHAR: case CLASS: case CONSTRUCTOR: case DEF: case DESTRUCTOR: case ENUM: case EVENT: case FINAL: case FOR: case FALSE: case GOTO: case INTERFACE: case INTERNAL: case IF: case NEW: case NULL: case OVERRIDE: case PARTIAL: case PUBLIC: case PROTECTED: case PRIVATE: case RAISE: case RETURN: case SELF: case SUPER: case STATIC: case STRUCT: case THEN: case TRY: case TRANSIENT: case TRUE: case TYPEOF: case UNLESS: case VIRTUAL: case WHILE: case YIELD: case TRIPLE_QUOTED_STRING: case LPAREN: case DOUBLE_QUOTED_STRING: case SINGLE_QUOTED_STRING: case ID: case MULTIPLY: case LBRACK: case SPLICE_BEGIN: case DOT: case COLON: case LBRACE: case QQ_BEGIN: case SUBTRACT: case LONG: case INCREMENT: case DECREMENT: case ONES_COMPLEMENT: case INT: case BACKTICK_QUOTED_STRING: case RE_LITERAL: case DOUBLE: case FLOAT: case TIMESPAN: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } { if ((LA(1)==THEN) && (LA(2)==COLON)) { et = LT(1); match(THEN); if (0==inputState.guessing) { fs.ThenBlock = new Block(ToLexicalInfo(et)); } compound_stmt(fs.ThenBlock); } else if ((tokenSet_84_.member(LA(1))) && (tokenSet_51_.member(LA(2)))) { } else { throw new NoViableAltException(LT(1), getFilename()); } } } catch (RecognitionException ex) { if (0 == inputState.guessing) { reportError(ex, "for_stmt"); recover(ex,tokenSet_84_); } else { throw ex; } } return fs; }
private LabelStatement CreateUpdateLabel(ForStatement node) { return new LabelStatement(LexicalInfo.Empty, Context.GetUniqueName("label")); }
private void EnterForNamespace(ForStatement node) { EnterNamespace(new DeclarationsNamespace(CurrentNamespace, node.Declarations)); }
private void FixContinueStatements(ForStatement node, WhileStatement ws) { // :update LabelStatement label = CreateUpdateLabel(node); GotoOnTopLevelContinue continueFixup = new GotoOnTopLevelContinue(label); node.Block.Accept(continueFixup); if (continueFixup.UsageCount > 0) ws.Block.Add(label); }
public override void OnForStatement(ForStatement node) { Visit(node.Iterator); node.Iterator = ProcessIterator(node.Iterator, node.Declarations); VisitForStatementBlock(node); }
public void ProcessUpdateableIteration(ForStatement node) { Expression expression = node.get_Iterator(); MethodInvocationExpression expression2 = this.get_CodeBuilder().CreateMethodInvocation(this._UnityRuntimeServices_GetEnumerator, node.get_Iterator()); expression2.set_LexicalInfo(new LexicalInfo(node.get_Iterator().get_LexicalInfo())); node.set_Iterator(expression2); this.ProcessDeclarationForIterator(node.get_Declarations().get_Item(0), this.GetEnumeratorItemType(this.GetExpressionType(expression))); this.VisitForStatementBlock(node); this.TransformIteration(node); }