public SyntaxKind GetKind()
{
if (Kind != SyntaxKind.None)
{
return(Kind);
}
return(SyntaxFacts.GetPrefixUnaryExpression(TameSyntaxFacts.SyntaxKindFromStr(OperatorTokenStr)));
}
public void TestPrefixUnaryOperators(SyntaxKind kind)
{
var text = kind.GetText() + "a";
var expr = ParseExpression(text);
Assert.NotNull(expr);
var opKind = SyntaxFacts.GetPrefixUnaryExpression(kind);
Assert.Equal(opKind, expr.Kind);
Assert.Equal(text, expr.ToString());
Assert.Equal(0, expr.GetDiagnostics().Count());
var us = (PrefixUnaryExpressionSyntax)expr;
Assert.NotNull(us.OperatorToken);
Assert.Equal(kind, us.OperatorToken.Kind);
Assert.NotNull(us.Operand);
Assert.Equal(SyntaxKind.IdentifierName, us.Operand.Kind);
Assert.Equal("a", us.Operand.ToString());
}
private ExpressionSyntax ParseUnityPossiblyNegativeNumericLiteralExpression()
{
if (Current.Kind == SyntaxKind.MinusToken)
{
var operatorToken = NextToken();
var literalToken = MatchOneOf(SyntaxKind.IntegerLiteralToken, SyntaxKind.FloatLiteralToken);
var operand = new LiteralExpressionSyntax(
SyntaxFacts.GetLiteralExpression(literalToken.Kind),
literalToken);
return(new PrefixUnaryExpressionSyntax(
SyntaxFacts.GetPrefixUnaryExpression(operatorToken.Kind),
operatorToken, operand));
}
else
{
var literalToken = MatchOneOf(SyntaxKind.IntegerLiteralToken, SyntaxKind.FloatLiteralToken);
return(new LiteralExpressionSyntax(
SyntaxFacts.GetLiteralExpression(literalToken.Kind),
literalToken));
}
}
private ExpressionSyntax ParseSubExpression(uint precedence)
{
if (Current.Kind == SyntaxKind.CompileKeyword)
{
var compile = Match(SyntaxKind.CompileKeyword);
var shaderTarget = Match(SyntaxKind.IdentifierToken);
var shaderFunctionName = ParseIdentifier();
var shaderFunction = new FunctionInvocationExpressionSyntax(shaderFunctionName, ParseParenthesizedArgumentList(false));
return(new CompileExpressionSyntax(compile, shaderTarget, shaderFunction));
}
ExpressionSyntax leftOperand;
SyntaxKind opKind;
// No left operand, so we need to parse one -- possibly preceded by a
// unary operator.
var tk = Current.Kind;
if (SyntaxFacts.IsPrefixUnaryExpression(tk))
{
opKind = SyntaxFacts.GetPrefixUnaryExpression(tk);
leftOperand = ParsePrefixUnaryExpression(opKind);
}
else
{
// Not a unary operator - get a primary expression.
leftOperand = ParseTerm();
}
while (true)
{
// We either have a binary or assignment or compound operator here, or we're finished.
tk = Current.Kind;
ExpressionOperatorType operatorType;
if (SyntaxFacts.IsBinaryExpression(tk) &&
(!_greaterThanTokenIsNotOperator || tk != SyntaxKind.GreaterThanToken) &&
(tk != SyntaxKind.GreaterThanToken || !_allowGreaterThanTokenAroundRhsExpression || Lookahead.Kind != SyntaxKind.SemiToken))
{
operatorType = ExpressionOperatorType.BinaryExpression;
opKind = SyntaxFacts.GetBinaryExpression(tk);
}
else if (SyntaxFacts.IsAssignmentExpression(tk))
{
operatorType = ExpressionOperatorType.AssignmentExpression;
opKind = SyntaxFacts.GetAssignmentExpression(tk);
}
else if (tk == SyntaxKind.CommaToken && CommaIsSeparatorStack.Peek() == false)
{
operatorType = ExpressionOperatorType.CompoundExpression;
opKind = SyntaxKind.CompoundExpression;
}
else
{
break;
}
var newPrecedence = SyntaxFacts.GetOperatorPrecedence(opKind);
Debug.Assert(newPrecedence > 0); // All binary operators must have precedence > 0!
// Check the precedence to see if we should "take" this operator
if (newPrecedence < precedence)
{
break;
}
// Same precedence, but not right-associative -- deal with this "later"
if (newPrecedence == precedence && !SyntaxFacts.IsRightAssociative(opKind))
{
break;
}
// Precedence is okay, so we'll "take" this operator.
var opToken = NextToken();
SyntaxToken lessThanToken = null;
if (operatorType == ExpressionOperatorType.AssignmentExpression && _allowGreaterThanTokenAroundRhsExpression)
{
lessThanToken = NextTokenIf(SyntaxKind.LessThanToken);
}
var rightOperand = ParseSubExpression(newPrecedence);
SyntaxToken greaterThanToken = null;
if (lessThanToken != null)
{
greaterThanToken = NextTokenIf(SyntaxKind.GreaterThanToken);
}
switch (operatorType)
{
case ExpressionOperatorType.BinaryExpression:
leftOperand = new BinaryExpressionSyntax(opKind, leftOperand, opToken, rightOperand);
break;
case ExpressionOperatorType.AssignmentExpression:
leftOperand = new AssignmentExpressionSyntax(opKind, leftOperand, opToken, lessThanToken, rightOperand, greaterThanToken);
break;
case ExpressionOperatorType.CompoundExpression:
leftOperand = new CompoundExpressionSyntax(opKind, leftOperand, opToken, rightOperand);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
var conditionalPrecedence = SyntaxFacts.GetOperatorPrecedence(SyntaxKind.ConditionalExpression);
if (tk == SyntaxKind.QuestionToken && precedence <= conditionalPrecedence)
{
var questionToken = NextToken();
var colonLeft = ParseSubExpression(conditionalPrecedence);
var colon = Match(SyntaxKind.ColonToken);
var colonRight = ParseSubExpression(conditionalPrecedence);
leftOperand = new ConditionalExpressionSyntax(leftOperand, questionToken, colonLeft, colon, colonRight);
}
return(leftOperand);
}
private ExpressionSyntax ParseDirectiveSubExpression(uint precedence)
{
ExpressionSyntax leftOperand;
SyntaxKind opKind;
// No left operand, so we need to parse one -- possibly preceded by a
// unary operator.
var tk = Current.Kind;
if (SyntaxFacts.IsPrefixUnaryExpression(tk, true))
{
opKind = SyntaxFacts.GetPrefixUnaryExpression(tk);
leftOperand = ParseDirectivePrefixUnaryExpression(opKind);
}
else
{
// Not a unary operator - get a primary expression.
leftOperand = ParseDirectiveTerm();
}
while (true)
{
// We either have a binary operator here, or we're finished.
tk = Current.Kind;
if (SyntaxFacts.IsBinaryExpression(tk))
{
opKind = SyntaxFacts.GetBinaryExpression(tk);
}
else
{
break;
}
var newPrecedence = SyntaxFacts.GetOperatorPrecedence(opKind);
Debug.Assert(newPrecedence > 0); // All binary operators must have precedence > 0!
// Check the precedence to see if we should "take" this operator
if (newPrecedence < precedence)
{
break;
}
// Same precedence, but not right-associative -- deal with this "later"
if (newPrecedence == precedence && !SyntaxFacts.IsRightAssociative(opKind))
{
break;
}
// Precedence is okay, so we'll "take" this operator.
var opToken = NextToken();
var rightOperand = ParseDirectiveSubExpression(newPrecedence);
leftOperand = new BinaryExpressionSyntax(opKind, leftOperand, opToken, rightOperand);
}
var conditionalPrecedence = SyntaxFacts.GetOperatorPrecedence(SyntaxKind.ConditionalExpression);
if (tk == SyntaxKind.QuestionToken && precedence <= conditionalPrecedence)
{
var questionToken = NextToken();
var colonLeft = ParseDirectiveSubExpression(conditionalPrecedence);
var colon = Match(SyntaxKind.ColonToken);
var colonRight = ParseDirectiveSubExpression(conditionalPrecedence);
leftOperand = new ConditionalExpressionSyntax(leftOperand, questionToken, colonLeft, colon, colonRight);
}
return(leftOperand);
}
