private Node ParseLogicalAnd()
{
var lNode = this.ParseEquality();
while (this.AreMoreTokens)
{
if (this.currentToken.Equals(TokenType.Symbol, "&"))
{
this.ReadNextToken();
lNode = new LogicalAndNode(lNode, this.ParseEquality());
}
else
{
break;
}
}
return(lNode);
}
public BinaryExpressionNode ParseBinaryExpresssion(Token operatorToken, AstNode leftOperand, AstNode rightOperand)
{
BinaryExpressionNode expression = null;
switch (operatorToken.Type)
{
case TokenType.Plus:
expression = new AdditionNode(operatorToken.SourceLine);
break;
case TokenType.Minus:
expression = new SubstractionNode(operatorToken.SourceLine);
break;
case TokenType.Asterisk:
expression = new MultiplicationNode(operatorToken.SourceLine);
break;
case TokenType.Slash:
expression = new DivisionNode(operatorToken.SourceLine);
break;
case TokenType.Equals:
expression = new EqualsComparisonNode(operatorToken.SourceLine);
break;
case TokenType.NotEquals:
expression = new NotEqualsComparisonNode(operatorToken.SourceLine);
break;
case TokenType.Less:
expression = new LessComparisonNode(operatorToken.SourceLine);
break;
case TokenType.EqualsOrLess:
expression = new EqualsOrLessComparisonNode(operatorToken.SourceLine);
break;
case TokenType.Greater:
expression = new GreaterComparisonNode(operatorToken.SourceLine);
break;
case TokenType.EqualsOrGreater:
expression = new EqualsOrGreaterComparisonNode(operatorToken.SourceLine);
break;
case TokenType.And:
expression = new LogicalAndNode(operatorToken.SourceLine);
break;
case TokenType.Or:
expression = new LogicalOrNode(operatorToken.SourceLine);
break;
default:
throw new CompilerException($"`{MethodBase.GetCurrentMethod().Name}` called with a bad token. Expected a binary operator, token has type `{operatorToken.Type}` instead.");
}
expression.LeftOperand = leftOperand;
expression.RightOperand = rightOperand;
return(expression);
}
// $ANTLR start "logicalANDExpression"
// JavaScript.g:255:1: logicalANDExpression : bitwiseORExpression ( ( LT )* ( '&&' ( LT )* bitwiseORExpression ) )* ;
public JavaScriptParser.logicalANDExpression_return logicalANDExpression() // throws RecognitionException [1]
{
JavaScriptParser.logicalANDExpression_return retval = new JavaScriptParser.logicalANDExpression_return();
retval.Start = input.LT(1);
object root_0 = null;
IToken LT292 = null;
IToken string_literal293 = null;
IToken LT294 = null;
JavaScriptParser.bitwiseORExpression_return bitwiseORExpression291 = default(JavaScriptParser.bitwiseORExpression_return);
JavaScriptParser.bitwiseORExpression_return bitwiseORExpression295 = default(JavaScriptParser.bitwiseORExpression_return);
object LT292_tree=null;
object string_literal293_tree=null;
object LT294_tree=null;
try
{
// JavaScript.g:256:2: ( bitwiseORExpression ( ( LT )* ( '&&' ( LT )* bitwiseORExpression ) )* )
// JavaScript.g:256:4: bitwiseORExpression ( ( LT )* ( '&&' ( LT )* bitwiseORExpression ) )*
{
root_0 = (object)adaptor.GetNilNode();
PushFollow(FOLLOW_bitwiseORExpression_in_logicalANDExpression2258);
bitwiseORExpression291 = bitwiseORExpression();
state.followingStackPointer--;
if (state.failed) return retval;
if ( state.backtracking == 0 ) adaptor.AddChild(root_0, bitwiseORExpression291.Tree);
// JavaScript.g:256:24: ( ( LT )* ( '&&' ( LT )* bitwiseORExpression ) )*
do
{
int alt153 = 2;
alt153 = dfa153.Predict(input);
switch (alt153)
{
case 1 :
// JavaScript.g:256:25: ( LT )* ( '&&' ( LT )* bitwiseORExpression )
{
// JavaScript.g:256:27: ( LT )*
do
{
int alt151 = 2;
int LA151_0 = input.LA(1);
if ( (LA151_0 == LT) )
{
alt151 = 1;
}
switch (alt151)
{
case 1 :
// JavaScript.g:256:27: LT
{
LT292=(IToken)Match(input,LT,FOLLOW_LT_in_logicalANDExpression2261); if (state.failed) return retval;
}
break;
default:
goto loop151;
}
} while (true);
loop151:
; // Stops C# compiler whining that label 'loop151' has no statements
// JavaScript.g:256:30: ( '&&' ( LT )* bitwiseORExpression )
// JavaScript.g:256:32: '&&' ( LT )* bitwiseORExpression
{
string_literal293=(IToken)Match(input,83,FOLLOW_83_in_logicalANDExpression2267); if (state.failed) return retval;
if ( state.backtracking == 0 )
{string_literal293_tree = new LogicalAndNode(string_literal293) ;
root_0 = (object)adaptor.BecomeRoot(string_literal293_tree, root_0);
}
// JavaScript.g:256:56: ( LT )*
do
{
int alt152 = 2;
int LA152_0 = input.LA(1);
if ( (LA152_0 == LT) )
{
alt152 = 1;
}
switch (alt152)
{
case 1 :
// JavaScript.g:256:56: LT
{
LT294=(IToken)Match(input,LT,FOLLOW_LT_in_logicalANDExpression2273); if (state.failed) return retval;
}
break;
default:
goto loop152;
}
} while (true);
loop152:
; // Stops C# compiler whining that label 'loop152' has no statements
PushFollow(FOLLOW_bitwiseORExpression_in_logicalANDExpression2277);
bitwiseORExpression295 = bitwiseORExpression();
state.followingStackPointer--;
if (state.failed) return retval;
if ( state.backtracking == 0 ) adaptor.AddChild(root_0, bitwiseORExpression295.Tree);
}
}
break;
default:
goto loop153;
}
} while (true);
loop153:
; // Stops C# compiler whining that label 'loop153' has no statements
}
retval.Stop = input.LT(-1);
if ( (state.backtracking==0) )
{ retval.Tree = (object)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
// Conversion of the second argument necessary, but harmless
retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
}
finally
{
}
return retval;
}
