public override AbstractNode VisitIfElseIfElse([NotNull] GiraphParser.IfElseIfElseContext context)
{
IfElseIfElseNode IfNode = new IfElseIfElseNode(context.Start.Line, context.Start.Column);
IfNode.IfCondition = Visit(context.boolCompOrExp()) as BoolComparisonNode;
IfNode.IfCodeBlock = Visit(context.codeBlock()) as CodeBlockNode;
if (context.elseifCond() != null)
{
// Loop though all the ElseIf(s)
foreach (var ElseIf in context.elseifCond())
{
// Add their conditions and codeblocks
IfNode.ElseIfList.Add(Tuple.Create((Visit(ElseIf.boolCompOrExp()) as BoolComparisonNode), (Visit(ElseIf.codeBlock()) as CodeBlockNode)));
}
}
// Else codeblock, First codeblock element, then it adopts the rest, if there are any
if (context.elseCond() != null)
{
// There will never be more then one Else block, and it does not have a boolcomparison
if (context.elseCond().codeBlock().ChildCount > 0)
{
IfNode.ElseCodeBlock = Visit(context.elseCond().codeBlock()) as CodeBlockNode;
}
}
return(IfNode);
}
public Node ElseIfList()
{
var elseIfList = new ListElseIf();
while (CurrentToken == TokenCategory.ELSEIF)
{
var elseIfToken = new ElseIf()
{
AnchorToken = Expect(TokenCategory.ELSEIF)
};
Expect(TokenCategory.PARENTHESIS_OPEN);
elseIfToken.Add(Expression());
Expect(TokenCategory.PARENTHESIS_CLOSE);
var n1 = new ListStatements();
Expect(TokenCategory.BRACE_OPEN);
while (firstOfStatement.Contains(CurrentToken))
{
n1.Add(Statement());
}
elseIfToken.Add(n1);
Expect(TokenCategory.BRACE_CLOSE);
elseIfList.Add(elseIfToken);
}
return(elseIfList);
}
public static IfThenElse CreateIfThenElse(List <BranchVM> branches)
{
if (branches.Count == 0)
{
return(null);
}
IfThenElse ifThenElse = CreateIfThenElse(branches[0]);
for (int i = 1; i < branches.Count; i++)
{
BranchVM branch = branches[i];
if (branch.IsTypeElseIf)
{
ElseIf elseIf = CreateElseIf(branch);
if (elseIf != null)
{
ifThenElse.ElseIfs.Add(elseIf);
}
}
else if (branch.IsTypeElse)
{
ifThenElse.ElseConstructId = branch.ThenConstruct.Id;
}
}
return(ifThenElse);
}
private static ElseIf CreateElseIf(BranchVM branch)
{
ElseIf elseIf = new ElseIf();
elseIf.IfCondition = CreateIfCondition(branch.ValidCondGroups);
elseIf.ThenConstructId = branch.ThenConstruct.Id;
return(elseIf);
}
/****************************************************************
* If Condition Node
***************************************************************/
public Node IfCondition()
{
var result = new If()
{
AnchorToken = Expect(TokenCategory.IF)
};
if (this.labelCache != null)
{
result.Add(this.labelCache);
this.labelCache = null;
}
var expr1 = Expression();
CheckForThen();
var stmtList1 = EvaluateStatements();
result.Add(expr1);
result.Add(stmtList1);
while (CurrentToken == TokenCategory.ELSEIF)
{
var elseIfToken = Expect(TokenCategory.ELSEIF);
var expr2 = Expression();
CheckForThen();
var stmtList2 = EvaluateStatements();
var elseIfResult = new ElseIf()
{
expr2, stmtList2
};
elseIfResult.AnchorToken = elseIfToken;
result.Add(elseIfResult);
}
if (CurrentToken == TokenCategory.ELSE)
{
var elseToken = Expect(TokenCategory.ELSE);
var stmtList3 = EvaluateStatements();
var elseResult = new Else()
{
AnchorToken = elseToken
};
elseResult.Add(stmtList3);
result.Add(elseResult);
}
if (CurrentToken == TokenCategory.ENDIF)
{
Expect(TokenCategory.ENDIF);
}
return(result);
}
public string Visit(ElseIf node)
{
var label = GenerateLabel();
return(Visit(((dynamic)node[0]))
+ "ldc.i4.1\n"
+ "bne.un '" + label + "'\n"
+ Visit(((dynamic)node[1]))
+ "'" + label + "':\n");
}
public string Visit(ElseIf node)
{
var sb = new StringBuilder();
sb.Append(" else\n");
sb.Append(Visit((dynamic)node[0]));
sb.Append(" if\n");
sb.Append(Visit((dynamic)node[1]));
return(sb.ToString());
}
public string Visit(ElseIf node)
{
var lbl = GenerateLabel();
return
(Visit(((dynamic)node[0]))
+ Line(Indent() + "ldc.i4 42")
+ Line(Indent() + "bne.un '" + lbl + "'")
+ Visit(((dynamic)node[1]))
+ Line(Indent() + "'" + lbl + "':"));
}
//-----------------------------------------------------------
public string Visit(ElseIf node)
{
var label = GenerateLabel();
return(String.Format(
"\t\t{0}\n\t\tldc.i4 42\n\t\tbne.un '{1}'\n\t\t{2}\n\t'{1}':\n",
Visit((dynamic)node[0]),
label,
Visit((dynamic)node[1])
));
}
public Type Visit(ElseIf node)
{
var condicion = Visit((dynamic)node[0]);
if (condicion != Type.BOOL)
{
throw new SemanticError("Exp must be of type BOOL, found: " + condicion, node[0].AnchorToken);
}
Visit((dynamic)node[1]);
return(Type.VOID);
}
public Node If()
{
var n1 = new If();
n1.AnchorToken = Expect(TokenType.IF);
Expect(TokenType.PARENTHESIS_OPEN);
n1.Add(Expression());
Expect(TokenType.PARENTHESIS_CLOSE);
Expect(TokenType.BLOCK_BEGIN);
var n2 = new StatementList();
while (firstOfStatement.Contains(CurrentToken))
{
n2.Add(Statement());
}
n1.Add(n2);
var n3 = new ElseIfList();
Expect(TokenType.BLOCK_END);
while (CurrentToken == TokenType.ELSEIF)
{
var nelsif = new ElseIf();
nelsif.AnchorToken = Expect(TokenType.ELSEIF);
Expect(TokenType.PARENTHESIS_OPEN);
nelsif.Add(Expression());
Expect(TokenType.PARENTHESIS_CLOSE);
Expect(TokenType.BLOCK_BEGIN);
var stmtList = new StatementList();
while (firstOfStatement.Contains(CurrentToken))
{
stmtList.Add(Statement());
}
nelsif.Add(stmtList);
n3.Add(nelsif);
Expect(TokenType.BLOCK_END);
}
n1.Add(n3);
var els = new Else();
if (CurrentToken == TokenType.ELSE)
{
els.AnchorToken = Expect(TokenType.ELSE);
Expect(TokenType.BLOCK_BEGIN);
var stmtList = new StatementList();
while (firstOfStatement.Contains(CurrentToken))
{
stmtList.Add(Statement());
}
els.Add(stmtList);
Expect(TokenType.BLOCK_END);
}
n1.Add(els);
return(n1);
}
public string Visit(ElseIf node)
{
string st = "";
var ifLabel = GenerateLabel();
st += Visit((dynamic)node[0]);
st += "\t\tldc.i4 42\n";
st += "\t\tbne.un " + ifLabel + "\n";
st += Visit((dynamic)node[1]);
st += "\t\t" + ifLabel + ":\n";
return(st);
}
public Type Visit(ElseIf node)
{
if (Visit((dynamic)node[0]) != Type.BOOL)
{
throw new SemanticError(
"Expecting type " + Type.BOOL
+ " in conditional statement",
node.AnchorToken);
}
VisitChildren(node[1]);
return(Type.VOID);
}
public string Visit(ElseIf node)
{
identSpaces++;
var lbl = GenerateLabel();
string result = Visit(((dynamic)node[0]))
+ putS(Indentar() + "ldc.i4 42")
+ putS(Indentar() + "bne.un '" + lbl + "'")
+ Visit(((dynamic)node[1]))
+ putS(Indentar() + "'" + lbl + "':");
identSpaces--;
return(result);
}
public string Visit(ElseIf node, string labelContinue)
{
var result = "";
result += node[0].GetType() == typeof(Identifier)? loadVariable(node[0].AnchorToken.Value): Visit((dynamic)node[0]);
var label1 = GenerateLabel();
result += "\t\tldc.i4 42\n\t\tbne.un " + label1 + "\n";
result += Visit((dynamic)node[1]);
result += "\t\tbr " + labelContinue + "\n";
result += "\t\t" + label1 + ":\n";
return(result);
}
public Node If()
{
var result = new If()
{
AnchorToken = Expect(TokenCategory.IF)
};
result.Add(Expression());
var thenstatement = new Then()
{
AnchorToken = Expect(TokenCategory.THEN)
};
while (firstOfStatement.Contains(CurrentToken))
{
thenstatement.Add(Statement());
}
result.Add(thenstatement);
while (CurrentToken == TokenCategory.ELSEIF)
{
var elif = new ElseIf()
{
AnchorToken = Expect(TokenCategory.ELSEIF)
};
elif.Add(Expression());
var thenst = new Then()
{
AnchorToken = Expect(TokenCategory.THEN)
};
while (firstOfStatement.Contains(CurrentToken))
{
thenst.Add(Statement());
}
elif.Add(thenst);
result.Add(elif);
}
if (CurrentToken == TokenCategory.ELSE)
{
var elsestatement = new Else()
{
AnchorToken = Expect(TokenCategory.ELSE)
};
while (firstOfStatement.Contains(CurrentToken))
{
elsestatement.Add(Statement());
}
}
Expect(TokenCategory.END);
Expect(TokenCategory.SEMICOL);
return(result);
}
internal override void Execute()
{
DeletedElseIf.ManageLinks();
if (_indexOfDeletedBranch < If.ElseIfList.Count - 1)
{
ElseIf elseIf = If.ElseIfList[_indexOfDeletedBranch + 1];
elseIf.Previous = DeletedElseIf.Previous;
}
if (_indexOfDeletedBranch > 0)
{
ElseIf elseIf = If.ElseIfList[_indexOfDeletedBranch - 1];
elseIf.Next = DeletedElseIf.Next;
}
}
//<elseif>//
public string Visit(ElseIf node)
{
var thisexit = elsifexit;
var tempLabel = GenerateLabel();
var sb = new StringBuilder();
sb.Append(Visit((dynamic)node[0]));
sb.Append("\t\tldc.i4 42\n");
sb.Append("\t\tbne.un " + tempLabel + "\n");
sb.Append(VisitAllButOne(node));
sb.Append("\t\tbr '" + thisexit + "'\n");
sb.Append("\t\t'" + tempLabel + "':\n");
thisexit = "";
return(sb.ToString());
}
public Node ElseIf()
{
var node = new ElseIfList();
while (CurrentToken == TokenCategory.ELSEIF)
{
var node_elseif = new ElseIf();
Expect(TokenCategory.ELSEIF);
Expect(TokenCategory.OPENEDPAR);
node_elseif.Add(Expr());
Expect(TokenCategory.CLOSEDPAR);
Expect(TokenCategory.OPENEDCURLY);
node_elseif.Add(StmtList());
Expect(TokenCategory.CLOSEDCURLY);
node.Add(node_elseif);
}
return(node);
}
public Node ElseIf(Token elseToken)
{
var statementElseIf = new ElseIf()
{
AnchorToken = elseToken
};
Expect(TokenCategory.IF);
Expect(TokenCategory.PARENTHESIS_OPEN);
statementElseIf.Add(Expr());
Expect(TokenCategory.PARENTHESIS_CLOSE);
Expect(TokenCategory.BRACKETS_OPEN);
statementElseIf.Add(StmtList());
Expect(TokenCategory.BRACKETS_CLOSE);
return(statementElseIf);
}
public Node ElseIf()
{
//elseif(‹expr›){‹stmt-list›} *
var n = new ElseIfList();
while (CurrentToken == TokenCategory.ELSEIF)
{
var n1 = new ElseIf();
Expect(TokenCategory.ELSEIF);
Expect(TokenCategory.OPENEDPAR);
n1.Add(Expr());
Expect(TokenCategory.CLOSEDPAR);
Expect(TokenCategory.OPENEDCURLY);
n1.Add(StmtList());
Expect(TokenCategory.CLOSEDCURLY);
n.Add(n1);
}
return(n);
}
public Node ElseIfList()
{
var elseIfList = new ElseIfList();
while (Current == TokenCategory.ELSEIF)
{
var elseIf = new ElseIf()
{
AnchorToken = Expect(TokenCategory.ELSEIF)
};
Expect(TokenCategory.OPEN_PARENTHESIS);
elseIf.Add(Expr());
Expect(TokenCategory.CLOSE_PARENTHESIS);
Expect(TokenCategory.OPEN_BRACKET);
elseIf.Add(StmtList());
Expect(TokenCategory.CLOSE_BRACKET);
elseIfList.Add(elseIf);
}
return(elseIfList);
}
//elseif side function//
public Node elseif()
{
var result = new ElseIf()
{
AnchorToken = Expect(TokenCategory.ELSEIF)
};
Expect(TokenCategory.PARENTHESIS_OPEN);
result.Add(Expression());
Expect(TokenCategory.PARENTHESIS_CLOSE);
Expect(TokenCategory.CURLY_BRACKET_OPEN);
result.Add(StmtList());
Expect(TokenCategory.CURLY_BRACKET_CLOSE);
return(result);
}
public Node ElseIfList()
{
var result = new ElseIfList();
while (CurrentToken == TokenCategory.ELIF)
{
var elifNode = new ElseIf();
var elif = Expect(TokenCategory.ELIF);
Expect(TokenCategory.PARENTHESIS_OPEN);
var expr = Expression();
elifNode.Add(expr);
Expect(TokenCategory.PARENTHESIS_CLOSE);
Expect(TokenCategory.BRACKET_OPEN);
var stmtList = StmtList();
elifNode.Add(stmtList);
Expect(TokenCategory.BRACKET_CLOSE);
elifNode.AnchorToken = elif;
result.Add(elifNode);
}
return(result);
}
private Node parseConditional()
{
If conditionalToken = (If)expect(typeof(If));
ConditionalNode conditional = new ConditionalNode();
conditional.setLineNumber(conditionalToken.getLineNumber());
conditional.setFileName(filename);
List <IfConditionNode> conditions = conditional.getConditions();
IfConditionNode main = new IfConditionNode(conditionalToken.getValue(), conditionalToken.getLineNumber());
main.setInverse(conditionalToken.isInverseCondition());
main.setBlock(block());
conditions.Add(main);
while (peek() is ElseIf)
{
ElseIf token = (ElseIf)expect(typeof(ElseIf))
;
IfConditionNode elseIf = new IfConditionNode(token.getValue(), token.getLineNumber());
elseIf.setBlock(block());
conditions.Add(elseIf);
}
if (peek() is Else)
{
Else token = (Else)expect(typeof(Else))
;
IfConditionNode elseNode = new IfConditionNode(null, token.getLineNumber());
elseNode.setDefault(true);
elseNode.setBlock(block());
conditions.Add(elseNode);
}
return(conditional);
}
public static CodeCompileUnit TestElseIfCodeCompileUnit()
{
CodeCompileUnit compileUnit = new CodeCompileUnit();
CodeNamespace codeNamespace = new CodeNamespace("Test.Namespace");
CodeTypeDeclaration classDeclaration = new CodeTypeDeclaration("TestClass")
{
IsClass = true
};
classDeclaration.TypeAttributes =
(classDeclaration.TypeAttributes & ~TypeAttributes.VisibilityMask) | TypeAttributes.Public;
var method = new CodeMemberMethod()
{
Name = "Method",
Attributes = MemberAttributes.Public | MemberAttributes.Final
};
method.Statements.Add(
ElseIf.New(
new Tuple <CodeExpression, IEnumerable <CodeStatement> >(
Primitives.Bool(true), new CodeStatement[] { new CodeMethodReturnStatement() })));
method.Statements.Add(
ElseIf.New(
new CodeStatement[] { new CodeMethodReturnStatement() },
new Tuple <CodeExpression, IEnumerable <CodeStatement> >(
Primitives.Int(1), new CodeStatement[] { new CodeMethodReturnStatement() }),
new Tuple <CodeExpression, IEnumerable <CodeStatement> >(
Primitives.Int(2), new CodeStatement[] { new CodeMethodReturnStatement() }),
new Tuple <CodeExpression, IEnumerable <CodeStatement> >(
Primitives.Int(3), new CodeStatement[] { new CodeMethodReturnStatement() })));
compileUnit.Namespaces.Add(codeNamespace);
codeNamespace.Types.Add(classDeclaration);
classDeclaration.Members.Add(method);
return(compileUnit);
}
public DeleteElseIfCommand(If @if, ElseIf existedElseIf)
{
If = @if;
DeletedElseIf = existedElseIf;
_indexOfDeletedBranch = If.ElseIfList.IndexOf(existedElseIf);
}
public void Visit(ElseIf node)
{
VisitChildren(node);
}
internal InsertElseIfAsNextCommand(If iif, ElseIf newElseIf, ElseIf existedElseIf)
{
this.If = iif;
this.InsertedElseIf = newElseIf;
this.ExistedElseIf = existedElseIf;
}
public override bool HasVariableDefined(Interpreter interpreter)
{
return((If != null && If.HasVariableDefined(interpreter)) || (ElseIf != null && ElseIf.Any(e => e.HasVariableDefined(interpreter))) || (Else != null && Else.HasVariableDefined(interpreter)));
}
