public MacroArgumentListSyntax ParseArgumentList()
{
var openParen = Match(SyntaxKind.OpenParenToken);
var arguments = new List <SyntaxNodeBase>();
CommaIsSeparatorStack.Push(true);
try
{
var currentArg = new List <SyntaxToken>();
var parenStack = 0;
while ((Current.Kind != SyntaxKind.CloseParenToken || parenStack > 0) && Current.Kind != SyntaxKind.EndOfFileToken)
{
switch (Current.Kind)
{
case SyntaxKind.OpenParenToken:
CommaIsSeparatorStack.Push(false);
parenStack++;
currentArg.Add(NextToken());
break;
case SyntaxKind.CloseParenToken:
CommaIsSeparatorStack.Pop();
parenStack--;
currentArg.Add(NextToken());
break;
case SyntaxKind.CommaToken:
if (CommaIsSeparatorStack.Peek() == false)
{
goto default;
}
arguments.Add(new MacroArgumentSyntax(currentArg));
currentArg = new List <SyntaxToken>();
arguments.Add(Match(SyntaxKind.CommaToken));
break;
default:
currentArg.Add(NextToken());
break;
}
}
if (currentArg.Any())
{
arguments.Add(new MacroArgumentSyntax(currentArg));
}
}
finally
{
CommaIsSeparatorStack.Pop();
}
var argumentList = new SeparatedSyntaxList <MacroArgumentSyntax>(arguments);
var closeParen = Match(SyntaxKind.CloseParenToken);
return(new MacroArgumentListSyntax(openParen, argumentList, closeParen));
}
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);
}