public override bool Equals(object obj)
{
var node = obj as IfThenElse;
if (node == null)
{
return(false);
}
if (IfExpr.Equals(node.IfExpr) == false)
{
return(false);
}
if (ThenExpr.Equals(node.ThenExpr) == false)
{
return(false);
}
if (ElseExpr.Equals(node.ElseExpr) == false)
{
return(false);
}
return(true);
}
public override string ToCode()
{
if (ElseExpr == null)
{
return($"{TokenValues.If} ({Condition.ToCode()}) {{\n{IfExpr.ToCode()}\n}}");
}
return($"{TokenValues.If} ({Condition.ToCode()}) {{\n{IfExpr.ToCode()}\n}} {TokenValues.Else} {{\n{ElseExpr.ToCode()}\n}}");
}
public override Expression Clone(Scope scope)
{
var ifExpr = new IfExpr(scope);
ifExpr.Conditions = Conditions.Clone(scope) as List;
ifExpr.Expressions = Expressions.Clone(scope) as List;
return(ifExpr);
}
/// <summary>
/// Visits the if statement tree.
/// </summary>
/// <param name="ifExpr"></param>
public void If(IfExpr ifExpr)
{
_callBack(ifExpr);
Visit(ifExpr.Condition);
foreach (var stmt in ifExpr.Statements)
{
Visit(stmt);
}
Visit(ifExpr.Else);
}
///
/// <param name="ifex">
/// is the 'if' expression. </param>
/// <returns> ifex expression. </returns>
public virtual object visit(IfExpr ifex)
{
for (IEnumerator <Expr> i = ifex.iterator(); i.MoveNext();)
{
i.Current.accept(this);
}
ifex.then_clause().accept(this);
ifex.else_clause().accept(this);
return(ifex);
}
/// <summary>
/// Validate an if expression.
/// </summary>
/// <param name="ifex">
/// is the if expression. </param>
/// <returns> null. </returns>
public virtual object visit(IfExpr ifex)
{
visitExprs(ifex.iterator());
ifex.then_clause().accept(this);
ifex.else_clause().accept(this);
return(null);
}
/// <summary>
/// Visits the if statement tree.
/// </summary>
/// <param name="ifExpr"></param>
public object VisitIf(IfExpr expr)
{
_callBackOnNodeStart(expr);
expr.Condition.Visit(this);
foreach (var stmt in expr.Statements)
{
stmt.Visit(this);
}
if (expr.Else != null)
{
expr.Else.Visit(this);
}
return(null);
}
private object Evaluate(Expr expression)
{
return(expression switch
{
BinaryExpr binaryExpr => Evaluate(binaryExpr),
BlockExpr blockExpr => Evaluate(blockExpr),
BreakExpr breakExpr => Evaluate(breakExpr),
CallExpr callExpr => Evaluate(callExpr),
ContinueExpr continueExpr => Evaluate(continueExpr),
Identifier identifier => Evaluate(identifier),
IfExpr ifExpr => Evaluate(ifExpr),
LambdaExpr lambdaExpr => Evaluate(lambdaExpr),
Literal literal => Evaluate(literal),
ReturnExpr returnExpr => Evaluate(returnExpr),
UnaryExpr unaryExpr => Evaluate(unaryExpr),
_ => throw new ArgumentOutOfRangeException(nameof(expression))
});
public Expr OnParseIf()
{
var tokenIt = this._parser.TokenIt;
var initiatorToken = tokenIt.NextToken;
var expr = new IfExpr();
// <codeIf>
tokenIt.Expect(Tokens.If);
// Parse the if
this.ParseConditionalBlock(expr);
tokenIt.AdvancePastNewLines();
// Handle "else if" and/or else
if (tokenIt.NextToken.Token == Tokens.Else)
{
// tokenIt.NextToken = "else"
tokenIt.Advance();
tokenIt.AdvancePastNewLines();
// What's after else?
// 1. "if" = else if statement
// 2. "{" = multi line else
// 3. "nothing" = single line else
// Peek 2nd token for else if.
var token = tokenIt.NextToken;
if (tokenIt.NextToken.Token == Tokens.If)
{
expr.Else = OnParseIf() as BlockExpr;
}
else // Multi-line or single line else
{
var elseStmt = new BlockExpr();
this._parser.ParseBlock(elseStmt);
this._parser.SetupContext(elseStmt, token);
expr.Else = elseStmt;
}
}
// </codeIf>
this._parser.SetupContext(expr, initiatorToken);
return(expr);
}
/// <summary>
/// return value;
/// </summary>
/// <returns></returns>
public override Expr Parse()
{
var stmt = new IfExpr();
var statements = new List<Expr>();
// While ( condition expression )
_tokenIt.Expect(Tokens.If);
// Parse the if
ParseConditionalBlock(stmt);
_tokenIt.AdvancePastNewLines();
// Handle "else if" and/or else
if (_tokenIt.NextToken.Token == Tokens.Else)
{
// _tokenIt.NextToken = "else"
_tokenIt.Advance();
_tokenIt.AdvancePastNewLines();
// What's after else?
// 1. "if" = else if statement
// 2. "{" = multi line else
// 3. "nothing" = single line else
// Peek 2nd token for else if.
var token = _tokenIt.NextToken;
if (_tokenIt.NextToken.Token == Tokens.If)
{
stmt.Else = Parse() as BlockExpr;
}
else // Multi-line or single line else
{
var elseStmt = new BlockExpr();
ParseBlock(elseStmt);
_parser.SetupContext(elseStmt, token);
stmt.Else = elseStmt;
}
}
return stmt;
}
/// <summary>
/// Execute
/// </summary>
public object VisitIf(IfExpr expr)
{
// Case 1: If is true
var result = expr.Condition.Evaluate(this) as LObject;
bool execIf = EvalHelper.IsTrue(result);
object returnVal = LObjects.Null;
if (execIf)
{
if (expr.Statements != null && expr.Statements.Count > 0)
{
foreach (var stmt in expr.Statements)
{
returnVal = stmt.Evaluate(this);
}
}
}
// Case 2: Else available to execute
else if (expr.Else != null)
{
returnVal = expr.Else.Evaluate(this);
}
return(returnVal);
}
public override TypeValidationResult CheckType()
{
var ifResult = IfExpr.CheckType();
if (ifResult.HasError)
{
return(ifResult);
}
if (ifResult.Type.Equals(new BooleanType()) == false)
{
return(TypeValidationResult.Invalid(Position, "IfThenElseOperator must have a boolean if expression"));
}
var thenResult = ThenExpr.CheckType();
if (thenResult.HasError)
{
return(thenResult);
}
var elseResult = ElseExpr.CheckType();
if (elseResult.HasError)
{
return(elseResult);
}
if (thenResult.Type.Equals(elseResult.Type) == false)
{
return(TypeValidationResult.Invalid(Position, "IfThenElse, type of then and else expression must be the same"));
}
Type = thenResult.Type;
return(TypeValidationResult.Valid(Type));
}
private void Resolve(IfExpr @if)
{
Resolve(@if.Condition);
Resolve(@if.Consequent);
Resolve(@if.Alternative);
}
/// <summary>
/// Visits the if statement tree.
/// </summary>
/// <param name="ifExpr"></param>
public object VisitIf(IfExpr expr)
{
_callBackOnNodeStart(expr);
expr.Condition.Visit(this);
foreach (var stmt in expr.Statements)
{
stmt.Visit(this);
}
if (expr.Else != null)
expr.Else.Visit(this);
return null;
}
public override string ToString()
{
StringBuilder sbIfExpr = new StringBuilder();
// Optional name
if (!string.IsNullOrEmpty(Name))
{
sbIfExpr.Append(Name);
sbIfExpr.Append(" ");
sbIfExpr.Append(":");
sbIfExpr.Append(" ");
}
// An ifnode must always have an expression
Validity.Assert(sbIfExpr != null);
// If expr
sbIfExpr.Append(ProtoCore.VHDL.Constants.Keyword.If);
sbIfExpr.Append(" ");
sbIfExpr.Append(IfExpr.ToString());
sbIfExpr.Append(" ");
sbIfExpr.Append(ProtoCore.VHDL.Constants.Keyword.Then);
sbIfExpr.Append("\n");
// If body
StringBuilder sbIfBody = new StringBuilder();
foreach (AST.VHDLNode node in IfBody)
{
sbIfBody.Append(node.ToString());
sbIfBody.Append("\n");
}
sbIfBody.Append("\n");
// Elsif expr
StringBuilder sbElsifStmt = new StringBuilder();
if (ElsifExprList.Count > 0)
{
for (int i = 0; i < ElsifExprList.Count; ++i)
{
VHDLNode exprNode = ElsifExprList[i];
sbElsifStmt.Append(ProtoCore.VHDL.Constants.Keyword.Elsif);
sbElsifStmt.Append(" ");
sbElsifStmt.Append(exprNode.ToString());
sbElsifStmt.Append(" ");
sbElsifStmt.Append(ProtoCore.VHDL.Constants.Keyword.Then);
sbElsifStmt.Append("\n");
// Elsif body
foreach (VHDLNode node in ElsifBodyList[i])
{
sbElsifStmt.Append(node.ToString());
sbElsifStmt.Append("\n");
}
sbElsifStmt.Append("\n");
}
}
// Else
StringBuilder sbElse = new StringBuilder();
StringBuilder sbElseBody = new StringBuilder();
if (ElseBody.Count > 0)
{
sbElse.Append(ProtoCore.VHDL.Constants.Keyword.Else);
sbElse.Append("\n\t");
// Else body
foreach (AST.VHDLNode node in ElseBody)
{
sbElseBody.Append(node.ToString());
sbElseBody.Append("\n");
}
sbElseBody.Append("\n");
}
StringBuilder sbEndIf = new StringBuilder();
sbEndIf.Append(ProtoCore.VHDL.Constants.Keyword.End);
sbEndIf.Append(" ");
sbEndIf.Append(ProtoCore.VHDL.Constants.Keyword.If);
sbEndIf.Append(" ");
sbEndIf.Append(Name);
sbEndIf.Append(";");
StringBuilder sbFormat = new StringBuilder();
sbFormat.Append(sbIfExpr);
sbFormat.Append(sbIfBody);
sbFormat.Append(sbElsifStmt);
sbFormat.Append(sbElse);
sbFormat.Append(sbElseBody);
sbFormat.Append(sbEndIf);
return(sbFormat.ToString());
}
public void SimpleExpression()
{
Analyzer a = new Analyzer();
Tokenizer p = new Tokenizer();
{
p.Reset("value");
p.IsErrorOrEndOfInput.Should().Be(false);
Expr e = a.Analyse(p);
e.Should().BeOfType <AccessorMemberExpr>();
AccessorMemberExpr ac = e as AccessorMemberExpr;
ac.IsUnbound.Should().Be(true);
}
{
p.Reset("!");
Expr e = a.Analyse(p);
e.Should().BeOfType <UnaryExpr>();
UnaryExpr u = e as UnaryExpr;
u.TokenType.Should().Be(TokenizerToken.Not);
u.Expression.Should().BeOfType <SyntaxErrorExpr>();
SyntaxErrorCollector.Collect(e, null).Count.Should().Be(1);
}
{
p.Reset("!value");
Expr e = a.Analyse(p);
e.Should().BeOfType <UnaryExpr>();
UnaryExpr u = e as UnaryExpr;
u.TokenType.Should().Be(TokenizerToken.Not);
u.Expression.Should().BeOfType <AccessorMemberExpr>();
SyntaxErrorCollector.Collect(e, null).Should().BeEmpty();
}
{
p.Reset(" 0.12e43 && ~b ");
Expr e = a.Analyse(p);
e.Should().BeOfType <BinaryExpr>();
BinaryExpr and = e as BinaryExpr;
and.BinaryOperatorToken.Should().Be(TokenizerToken.And);
IsConstant(and.Left, 0.12e43);
and.Right.Should().BeOfType <UnaryExpr>();
UnaryExpr u = and.Right as UnaryExpr;
u.TokenType.Should().Be(TokenizerToken.BitwiseNot);
u.Expression.Should().BeOfType <AccessorMemberExpr>();
AccessorMemberExpr m = u.Expression as AccessorMemberExpr;
m.Left.Should().BeNull();
SyntaxErrorCollector.Collect(e, null).Should().BeEmpty();
}
{
p.Reset(@"!a||~""x""");
Expr e = a.Analyse(p);
e.Should().BeOfType <BinaryExpr>();
BinaryExpr or = e as BinaryExpr;
or.BinaryOperatorToken.Should().Be(TokenizerToken.Or);
or.Left.Should().BeOfType <UnaryExpr>();
or.Right.Should().BeOfType <UnaryExpr>();
UnaryExpr u = or.Right as UnaryExpr;
u.TokenType.Should().Be(TokenizerToken.BitwiseNot);
IsConstant(u.Expression, "x");
SyntaxErrorCollector.Collect(e, null).Should().BeEmpty();
}
{
p.Reset("(3)");
Expr e = a.Analyse(p);
IsConstant(e, 3.0);
}
{
p.Reset("(3+typeof 'x')");
Expr e = a.Analyse(p);
e.Should().BeOfType <BinaryExpr>();
BinaryExpr b = e as BinaryExpr;
IsConstant(b.Left, 3.0);
b.Right.Should().BeOfType <UnaryExpr>();
UnaryExpr u = b.Right as UnaryExpr;
u.TokenType.Should().Be(TokenizerToken.TypeOf);
IsConstant(u.Expression, "x");
SyntaxErrorCollector.Collect(e, null).Should().BeEmpty();
}
{
p.Reset("1 ? 2 : 3");
Expr e = a.Analyse(p);
e.Should().BeOfType <IfExpr>();
IfExpr i = e as IfExpr;
i.IsTernaryOperator.Should().Be(true);
IsConstant(i.Condition, 1.0);
IsConstant(i.WhenTrue, 2.0);
IsConstant(i.WhenFalse, 3.0);
}
}
public void SimpleExpression()
{
ExprAnalyser a = new ExprAnalyser();
JSTokenizer p = new JSTokenizer();
{
p.Reset("value");
Assert.That(p.IsErrorOrEndOfInput, Is.False);
Expr e = a.Analyse(p);
Assert.That(e is AccessorMemberExpr);
AccessorMemberExpr ac = e as AccessorMemberExpr;
Assert.That(ac.IsUnbound == true);
}
{
p.Reset("!");
Expr e = a.Analyse(p);
Assert.That(e is UnaryExpr);
UnaryExpr u = e as UnaryExpr;
Assert.That(u.TokenType == JSTokenizerToken.Not);
Assert.That(u.Expression is SyntaxErrorExpr);
Assert.That(SyntaxErrorCollector.Collect(e, null).Count == 1);
}
{
p.Reset("!value");
Expr e = a.Analyse(p);
Assert.That(e is UnaryExpr);
UnaryExpr u = e as UnaryExpr;
Assert.That(u.TokenType == JSTokenizerToken.Not);
Assert.That(u.Expression is AccessorExpr);
Assert.That(SyntaxErrorCollector.Collect(e, Util.ActionVoid).Count == 0);
}
{
p.Reset(" 0.12e43 && ~b ");
Expr e = a.Analyse(p);
Assert.That(e is BinaryExpr);
BinaryExpr and = e as BinaryExpr;
Assert.That(and.BinaryOperatorToken == JSTokenizerToken.And);
IsConstant(and.Left, 0.12e43);
Assert.That(and.Right is UnaryExpr);
UnaryExpr u = and.Right as UnaryExpr;
Assert.That(u.TokenType == JSTokenizerToken.BitwiseNot);
Assert.That(u.Expression is AccessorExpr);
Assert.That(SyntaxErrorCollector.Collect(e, Util.ActionVoid).Count == 0);
}
{
p.Reset(@"!a||~""x""");
Expr e = a.Analyse(p);
Assert.That(e is BinaryExpr);
BinaryExpr or = e as BinaryExpr;
Assert.That(or.BinaryOperatorToken == JSTokenizerToken.Or);
Assert.That(or.Left is UnaryExpr);
Assert.That(or.Right is UnaryExpr);
UnaryExpr u = or.Right as UnaryExpr;
Assert.That(u.TokenType == JSTokenizerToken.BitwiseNot);
IsConstant(u.Expression, "x");
Assert.That(SyntaxErrorCollector.Collect(e, Util.ActionVoid).Count == 0);
}
{
p.Reset("(3)");
Expr e = a.Analyse(p);
IsConstant(e, 3);
}
{
p.Reset("(3+typeof 'x')");
Expr e = a.Analyse(p);
Assert.That(e is BinaryExpr);
BinaryExpr b = e as BinaryExpr;
IsConstant(b.Left, 3);
Assert.That(b.Right is UnaryExpr);
UnaryExpr u = b.Right as UnaryExpr;
Assert.That(u.TokenType == JSTokenizerToken.TypeOf);
IsConstant(u.Expression, "x");
Assert.That(SyntaxErrorCollector.Collect(e, Util.ActionVoid).Count == 0);
}
{
p.Reset("1 ? 2 : 3");
Expr e = a.Analyse(p);
Assert.That(e is IfExpr);
IfExpr i = e as IfExpr;
Assert.That(i.IsTernaryOperator == true);
IsConstant(i.Condition, 1);
IsConstant(i.WhenTrue, 2);
IsConstant(i.WhenFalse, 3);
}
}
