protected virtual ParenthesizedExpressionNode ParseParenthesizedExpression(IPrimaryParentNode parent, SpecialCharacterToken leftParenthesis)
{
// PARSE: '(' <expression> ')'
ParenthesizedExpressionNode result = new ParenthesizedExpressionNode(parent, leftParenthesis);
Token token = this.GetNextTokenxx(Preference.NegativeSign);
ExpressionNode expression = this.ParseExpression(result, token);
if (expression == null)
{
this.ReportParserError(result, SemanticErrors.MissingExpression, token);
return(result);
}
// Ensure the parentheses are properly closed.
token = this.GetNextTokenxx(Preference.Default);
SpecialCharacterToken rightParenthesis = null;
if (Parser.IsClosingParenthesis(token))
{
rightParenthesis = (SpecialCharacterToken)token;
}
else
{
this.ReportParserError(result, SemanticErrors.MissingExpressionClosingParenthesis, token);
this.ResidueToken = token;
}
result.SetContents(expression, rightParenthesis);
return(result);
}
public override Node visitParenthesizedExpression(JuliarParser.ParenthesizedExpressionContext ctx)
{
ParenthesizedExpressionNode node = new ParenthesizedExpressionNode();
iterateWithTryCatch(ctx, node);
return(node);
}
public override Expression VisitParenthesizedExpression(ParenthesizedExpressionNode node)
{
ExpressionVisitor visitor = new ExpressionVisitor(this);
Expression result = node.Expression.Accept(visitor);
this.IsConstant = visitor.IsConstant;
return(result);
}
/// <summary>
/// Visits the Parenthesized Expression node.
/// </summary>
/// <param name="node">The node to visit.</param>
public virtual TResult VisitParenthesizedExpression(ParenthesizedExpressionNode node)
{
if (node.Expression != null)
{
node.Expression.Accept(this);
}
return(default(TResult)); // The default naive implementation
}
/// <summary>
/// Visits the Parenthesized Expression node.
/// </summary>
/// <param name="node">The node to visit.</param>
public override bool VisitParenthesizedExpression(ParenthesizedExpressionNode node)
{
if (node.Parent == null)
{
return(false);
}
if ((node.LeftParenthesis == null) ^ (node.RightParenthesis == null))
{
return(false);
}
if ((node.Expression == null) || !node.Expression.Accept(this))
{
return(false);
}
return(true);
}
/// <summary>
/// Visits the Parenthesized Expression node.
/// </summary>
/// <param name="node">The node to visit.</param>
public virtual TResult VisitParenthesizedExpression(ParenthesizedExpressionNode node)
{
throw new NotImplementedException();
}
public override Expression VisitParenthesizedExpression(ParenthesizedExpressionNode node)
{
return(node.Expression.Accept(new ExpressionVisitor(this)));
}
public virtual void VisitParenthesizedExpressionNode(ParenthesizedExpressionNode node)
{
Visit(node.OpenParenthesisNode);
Visit(node.ExpressionNode);
Visit(node.CloseParenthesisNode);
}
public virtual void VisitParenthesizedExpressionNode(ParenthesizedExpressionNode node)
{
Visit(node.OpenParenthesisNode);
Visit(node.ExpressionNode);
Visit(node.CloseParenthesisNode);
}
private Expression BindParenthesizedExpression(ParenthesizedExpressionNode node) => DoBindExpression(node.Expression);
private List <ExpressionNode> PrimaryExpression()
{
printDebug("Primary Expression");
if (Match(TokenType.NEW_KEYWORD))
{
ConsumeToken();
var left = InstanceExpression();
var right = PrimaryExpressionPrime();
var ret = new List <ExpressionNode>();
ret.Add(left);
ret.AddRange(right);
return(ret);
}
else if (MatchAny(this.literals))
{
var token = ConsumeToken();
var left = new LiteralExpressionNode(token) as ExpressionNode;
var right = PrimaryExpressionPrime();
var ret = new List <ExpressionNode>();
ret.Add(left);
ret.AddRange(right);
return(ret);
}
else if (Match(TokenType.ID))
{
var token = ConsumeToken();
var left = new IdentifierExpressionNode(token) as ExpressionNode;
var right = PrimaryExpressionPrime();
var ret = new List <ExpressionNode>();
if (right.Count > 0 &&
(
(right[0] is FunctionCallExpressionNode && ((FunctionCallExpressionNode)right[0]).identifier == null) ||
(right[0] is ArrayAccessExpressionNode && ((ArrayAccessExpressionNode)right[0]).identifier == null) ||
(right[0] is PostAdditiveExpressionNode && ((PostAdditiveExpressionNode)right[0]).indentifier == null)
)
)
{
if (right[0] is FunctionCallExpressionNode)
{
((FunctionCallExpressionNode)right[0]).identifier = left;
}
else if (right[0] is ArrayAccessExpressionNode)
{
((ArrayAccessExpressionNode)right[0]).identifier = left;
}
else
{
((PostAdditiveExpressionNode)right[0]).indentifier = left;
}
}
else
{
ret.Add(left);
}
ret.AddRange(right);
return(ret);
}
else if (Match(TokenType.PAREN_OPEN))
{
ConsumeToken();
var expr = Expression();
MatchExactly(TokenType.PAREN_CLOSE);
var right = PrimaryExpressionPrime();
//REVISAR EL PRIMARY EXPRESSION PRIME
if (right.Count > 0 && (right[0] is FunctionCallExpressionNode || right[0] is ArrayAccessExpressionNode || (right[0] is PostAdditiveExpressionNode)))
{
if (right[0] is FunctionCallExpressionNode)
{
((FunctionCallExpressionNode)right[0]).identifier = expr;
}
else if (right[0] is ArrayAccessExpressionNode)
{
((ArrayAccessExpressionNode)right[0]).identifier = expr;
}
else
{
((PostAdditiveExpressionNode)right[0]).indentifier = expr;
}
return(right);
}
else
{
var internal_expression = new ParenthesizedExpressionNode(expr);
var ret = new List <ExpressionNode>();
ret.Add(internal_expression);
ret.AddRange(right);
return(ret);
}
}
else if (Match(TokenType.THIS_KEYWORD))
{
var token = MatchExactly(TokenType.THIS_KEYWORD);
var left = new ReferenceAccessNode(token) as ExpressionNode;
var right = PrimaryExpressionPrime();
var ret = new List <ExpressionNode>();
ret.Add(left);
ret.AddRange(right);
return(ret);
}
else if (Match(TokenType.BASE_KEYWORD))
{
var token = MatchExactly(TokenType.BASE_KEYWORD);
var left = new ReferenceAccessNode(token) as ExpressionNode;
var right = PrimaryExpressionPrime();
var ret = new List <ExpressionNode>();
ret.Add(left);
ret.AddRange(right);
return(ret);
}
else if (MatchAny(this.buildInTypes))
{
var token = ConsumeToken();
var left = new BuiltInTypeExpressionNode(token) as ExpressionNode;
var right = PrimaryExpressionPrime();
var ret = new List <ExpressionNode>();
ret.Add(left);
ret.AddRange(right);
return(ret);
}
else
{
ThrowSyntaxException("new, literal, identifier, '(' or 'this' expected");
return(null);
}
}
