public override IEnumerable <string> Visit(IfElseIfStatement node) { StringBuilder first = new StringBuilder("if ( "); foreach (var str in node.Nodes <BooleanExpression>()[0].Accept(this).Where(s => !string.IsNullOrWhiteSpace(s))) { first.Append(str); } first.Append(" )"); yield return(first.ToString()); yield return("{"); foreach (var str in node.Nodes <Declaration>()[0].Accept(this)) { yield return($" {str}"); } foreach (var str in node.Nodes <Statement>()[0].Accept(this)) { yield return($" {str}"); } yield return("}"); yield return("else"); foreach (var str in node[9].Accept(this)) { yield return(str); } }
private Statement FixSwitchingStatement(Statement statement) { if (statement is SwitchStatement) { SwitchStatement theSwitch = statement as SwitchStatement; if (theSwitch.Condition.Equals(theIntVariable)) { theSwitch.Condition = theStringVariable.CloneExpressionOnly(); } foreach (SwitchCase @case in theSwitch.Cases) { if (@case is ConditionCase) { ConditionCase condCase = @case as ConditionCase; int caseValue = (int)(condCase.Condition as LiteralExpression).Value; condCase.Condition = new LiteralExpression(valueDictionary[caseValue], theTypeSystem, null); } } } else if (statement is IfElseIfStatement) { IfElseIfStatement irregularSwitch = statement as IfElseIfStatement; foreach (KeyValuePair <Expression, BlockStatement> condPair in irregularSwitch.ConditionBlocks) { FixConditionExpression(condPair.Key as BinaryExpression); } } return(statement); }
private bool TryGetSwitchData(IfElseIfStatement node, out CreateCompilerOptimizedSwitchByStringStatementsStep.SwitchData data) { data = new CreateCompilerOptimizedSwitchByStringStatementsStep.SwitchData(); V_0 = node.get_ConditionBlocks().GetEnumerator(); try { while (V_0.MoveNext()) { V_1 = V_0.get_Current(); if (this.TryMatchCondition(V_1.get_Key(), V_1.get_Value(), data)) { continue; } V_2 = false; goto Label1; } goto Label0; } finally { ((IDisposable)V_0).Dispose(); } Label1: return(V_2); Label0: if (node.get_Else() != null) { data.set_DefaultCase(node.get_Else()); } return(true); }
private IfElseIfStatement BuildIfElseIfStatement(IfStatement theIf) { // at this point we are sure, that the statement is either IfStatement or IfElseIfStatement Statement elseStatement = theIf.Else.Statements[0]; if (elseStatement.CodeNodeType == CodeNodeType.IfStatement) { IfStatement innerIf = (IfStatement)elseStatement; List <KeyValuePair <Expression, BlockStatement> > ifChain = new List <KeyValuePair <Expression, BlockStatement> >(); KeyValuePair <Expression, BlockStatement> theFirstPair = new KeyValuePair <Expression, BlockStatement>(theIf.Condition, theIf.Then); KeyValuePair <Expression, BlockStatement> theSecondPair = new KeyValuePair <Expression, BlockStatement>(innerIf.Condition, innerIf.Then); ifChain.Add(theFirstPair); ifChain.Add(theSecondPair); IfElseIfStatement result = new IfElseIfStatement(ifChain, innerIf.Else); return(result); } else { IfElseIfStatement innerIfElseIf = (IfElseIfStatement)elseStatement; List <KeyValuePair <Expression, BlockStatement> > ifChain = innerIfElseIf.ConditionBlocks; KeyValuePair <Expression, BlockStatement> outerPair = new KeyValuePair <Expression, BlockStatement>(theIf.Condition, theIf.Then); ifChain.Insert(0, outerPair); theIf.Then.Parent = innerIfElseIf; return(innerIfElseIf); } }
private bool CheckSwitcingIfBody(BlockStatement body) { if (body.Statements.Count < 1) { return(false); } Statement theStatement = body.Statements[0]; if (theStatement is SwitchStatement) { SwitchStatement theSwitch = theStatement as SwitchStatement; if (theSwitch.Condition.Equals(IntVariable)) { return(true); } return(false); } if (theStatement is IfElseIfStatement) { IfElseIfStatement theIrregularSwitch = theStatement as IfElseIfStatement; foreach (KeyValuePair <Expression, BlockStatement> condBlock in theIrregularSwitch.ConditionBlocks) { BinaryExpression theCondition = condBlock.Key as BinaryExpression; if (theCondition == null || !CheckIrregularSwitchCaseCondition(theCondition)) { return(false); } } return(true); } return(false); }
/// <summary> /// Checks if after the execution of the statements in <paramref name="caseBody"/> the control flow will be transfered to the next statement. /// </summary> /// <param name="caseBody">The block to be checked.</param> /// <returns>Returns false if all code paths in the block exit at a point, different from the follow node (possibly even out of the method via /// throw ot return). Otherwise returns true.</returns> public static bool BlockHasFallThroughSemantics(BlockStatement caseBody) { if (caseBody == null) { return(false); } if (caseBody.Statements.Count == 0) { return(true); } var lastStatement = caseBody.Statements[caseBody.Statements.Count - 1]; if (lastStatement.CodeNodeType == CodeNodeType.ExpressionStatement) { Expression expression = (lastStatement as ExpressionStatement).Expression; if (expression != null && expression.CodeNodeType == CodeNodeType.ReturnExpression || expression.CodeNodeType == CodeNodeType.ThrowExpression) { return(false); } } else if (lastStatement.CodeNodeType == CodeNodeType.BreakStatement || lastStatement.CodeNodeType == CodeNodeType.ContinueStatement || lastStatement.CodeNodeType == CodeNodeType.GotoStatement) { return(false); } else if (lastStatement.CodeNodeType == CodeNodeType.IfStatement) { IfStatement theIf = lastStatement as IfStatement; if (theIf.Else != null) { return(BlockHasFallThroughSemantics(theIf.Else) || BlockHasFallThroughSemantics(theIf.Then)); } } else if (lastStatement.CodeNodeType == CodeNodeType.IfElseIfStatement) { IfElseIfStatement theIfElseIf = lastStatement as IfElseIfStatement; if (theIfElseIf.Else == null) { return(true); } bool result = BlockHasFallThroughSemantics(theIfElseIf.Else); if (result == false) { return(false); } foreach (KeyValuePair <Expression, BlockStatement> pair in theIfElseIf.ConditionBlocks) { result |= BlockHasFallThroughSemantics(pair.Value); if (result == false) { return(false); } } } return(true); }
public override ICodeNode VisitIfElseIfStatement(IfElseIfStatement node) { if (!this.IsSwitchByString(node) || !this.TryGetSwitchData(node, out V_0)) { return(this.VisitIfElseIfStatement(node)); } return(this.Visit(this.ComposeSwitch(V_0))); }
public override ICodeNode VisitIfElseIfStatement(IfElseIfStatement node) { stackVariable1 = node.get_ConditionBlocks(); V_0 = node.get_ConditionBlocks().get_Item(0); stackVariable11 = (Expression)this.Visit(V_0.get_Key()); V_0 = node.get_ConditionBlocks().get_Item(0); stackVariable1.set_Item(0, new KeyValuePair <Expression, BlockStatement>(stackVariable11, V_0.get_Value())); return(node); }
private IfElseIfStatement HandleDirectIfStatement(IfStatement theIf) { /// At this point we are sure, that if-else-if statement can be created without reverting the condition /// Now we need to perform checks if we can create if-else-if statement after reversing and to chose which one to create /// if (theIf.Then.Statements.Count != 1) { /// There is only one way in which we can create the if-else-if statement IfElseIfStatement result = BuildIfElseIfStatement(theIf); return(result); } Statement thenStatement = theIf.Then.Statements[0]; if (thenStatement.CodeNodeType != CodeNodeType.IfElseIfStatement && thenStatement.CodeNodeType != CodeNodeType.IfStatement) { /// There is only one way in which we can create the if-else-if statement IfElseIfStatement result = BuildIfElseIfStatement(theIf); return(result); } Statement elseStatement = theIf.Else.Statements[0]; if (elseStatement.CodeNodeType == CodeNodeType.IfStatement) { /// If the else statement is only if-statement, then we invert the code anyways /// best case: the then statement was if-else-if, and we get one level nesting less /// worst case: the then statemnt was if-statement as well and we get the same level of nesting as if we haven't inverted InvertIfStatement(theIf); IfElseIfStatement result = BuildIfElseIfStatement(theIf); return(result); } /// from this point the else statement is known to be if-else-if statement /// if (thenStatement.CodeNodeType == CodeNodeType.IfStatement) { /// This way we will continue the if-else-if statement in the else block IfElseIfStatement result = BuildIfElseIfStatement(theIf); return(result); } IfElseIfStatement elseIfElseStatement = (IfElseIfStatement)elseStatement; IfElseIfStatement thenIfElseStatement = (IfElseIfStatement)thenStatement; if (thenIfElseStatement.ConditionBlocks.Count >= elseIfElseStatement.ConditionBlocks.Count) { InvertIfStatement(theIf); } IfElseIfStatement endResult = BuildIfElseIfStatement(theIf); return(endResult); }
public virtual void VisitIfElseIfStatement(IfElseIfStatement node) { for (int i = 0; i < node.ConditionBlocks.Count; i++) { KeyValuePair <Expression, BlockStatement> pair = node.ConditionBlocks[i]; Visit(pair.Key); Visit(pair.Value); } Visit(node.Else); }
public override ICodeNode VisitIfElseIfStatement(IfElseIfStatement node) { SwitchData data; if (IsSwitchByString(node) && TryGetSwitchData(node, out data)) { return(Visit(ComposeSwitch(data))); } return(base.VisitIfElseIfStatement(node)); }
public virtual void VisitIfElseIfStatement(IfElseIfStatement node) { V_0 = 0; while (V_0 < node.get_ConditionBlocks().get_Count()) { V_1 = node.get_ConditionBlocks().get_Item(V_0); this.Visit(V_1.get_Key()); this.Visit(V_1.get_Value()); V_0 = V_0 + 1; } this.Visit(node.get_Else()); return; }
public virtual ICodeNode VisitIfElseIfStatement(IfElseIfStatement node) { for (int i = 0; i < node.ConditionBlocks.Count; i++) { Expression transformedCondition = (Expression)Visit(node.ConditionBlocks[i].Key); BlockStatement transformedBlock = (BlockStatement)Visit(node.ConditionBlocks[i].Value); transformedBlock.Parent = node; node.ConditionBlocks[i] = new KeyValuePair <Expression, BlockStatement>(transformedCondition, transformedBlock); } node.Else = (BlockStatement)Visit(node.Else); return(node); }
private bool IsSwitchByString(IfElseIfStatement node) { foreach (KeyValuePair <int, List <int> > pair in this.switchByStringData.SwitchBlocksToCasesMap) { foreach (int caseOffset in pair.Value) { if (node.SearchableUnderlyingSameMethodInstructionOffsets.Contains(caseOffset)) { return(true); } } } return(false); }
public virtual ICodeNode VisitIfElseIfStatement(IfElseIfStatement node) { V_0 = 0; while (V_0 < node.get_ConditionBlocks().get_Count()) { V_3 = node.get_ConditionBlocks().get_Item(V_0); V_1 = (Expression)this.Visit(V_3.get_Key()); V_3 = node.get_ConditionBlocks().get_Item(V_0); V_2 = (BlockStatement)this.Visit(V_3.get_Value()); V_2.set_Parent(node); node.get_ConditionBlocks().set_Item(V_0, new KeyValuePair <Expression, BlockStatement>(V_1, V_2)); V_0 = V_0 + 1; } node.set_Else((BlockStatement)this.Visit(node.get_Else())); return(node); }
public override ICodeNode VisitIfStatement(IfStatement node) { ICodeNode transformedNode = base.VisitIfStatement(node); if (transformedNode.CodeNodeType != CodeNodeType.IfStatement) { return(transformedNode); } IfStatement theIf = (IfStatement)transformedNode; if (theIf.Else == null) { return(theIf); } if (theIf.Else.Statements.Count == 1) { Statement elseStatement = theIf.Else.Statements[0]; if (elseStatement.CodeNodeType == CodeNodeType.IfStatement || elseStatement.CodeNodeType == CodeNodeType.IfElseIfStatement) { IfElseIfStatement resultingIfElseIf = HandleDirectIfStatement(theIf); return(resultingIfElseIf); } } if (theIf.Then.Statements.Count != 1) { return(theIf); } Statement thenStatement = theIf.Then.Statements[0]; if (thenStatement.CodeNodeType != CodeNodeType.IfStatement && thenStatement.CodeNodeType != CodeNodeType.IfElseIfStatement) { return(theIf); } InvertIfStatement(theIf); IfElseIfStatement result = BuildIfElseIfStatement(theIf); return(result); }
private bool TryGetSwitchData(IfElseIfStatement node, out SwitchData data) { data = new SwitchData(); foreach (KeyValuePair <Expression, BlockStatement> pair in node.ConditionBlocks) { if (!TryMatchCondition(pair.Key, pair.Value, data)) { return(false); } } if (node.Else != null) { data.DefaultCase = node.Else; } return(true); }
private bool IsSwitchByString(IfElseIfStatement node) { V_0 = this.switchByStringData.get_SwitchBlocksToCasesMap().GetEnumerator(); try { while (V_0.MoveNext()) { V_1 = V_0.get_Current(); V_2 = V_1.get_Value().GetEnumerator(); try { while (V_2.MoveNext()) { V_3 = V_2.get_Current(); if (!node.get_SearchableUnderlyingSameMethodInstructionOffsets().Contains(V_3)) { continue; } V_4 = true; goto Label1; } } finally { ((IDisposable)V_2).Dispose(); } } goto Label0; } finally { ((IDisposable)V_0).Dispose(); } Label1: return(V_4); Label0: return(false); }
public override void VisitIfElseIfStatement(IfElseIfStatement node) { V_0 = node.get_ConditionBlocks().get_Item(0); this.Visit(V_0.get_Key()); return; }