private void ParseArgumentList(SyntaxKind openKind, SyntaxKind closeKind, bool atLeastOneArg, out SyntaxToken openToken, out SeparatedSyntaxList <ExpressionSyntax> arguments, out SyntaxToken closeToken) { openToken = Match(openKind); var args = new List <SyntaxNodeBase>(); if (atLeastOneArg || Current.Kind != closeKind) { CommaIsSeparatorStack.Push(true); try { args.Add(ParseExpression()); while (Current.Kind == SyntaxKind.CommaToken) { args.Add(Match(SyntaxKind.CommaToken)); args.Add(ParseExpression()); } } finally { CommaIsSeparatorStack.Pop(); } } arguments = new SeparatedSyntaxList <ExpressionSyntax>(args); closeToken = Match(closeKind); }
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 PredefinedObjectTypeSyntax ParsePatchType(SyntaxToken token) { var lessThan = Match(SyntaxKind.LessThanToken); var userDefinedType = ParseIdentifier(); var comma = Match(SyntaxKind.CommaToken); ExpressionSyntax controlPoints; try { CommaIsSeparatorStack.Push(true); _greaterThanTokenIsNotOperator = true; controlPoints = ParseExpression(); } finally { _greaterThanTokenIsNotOperator = false; CommaIsSeparatorStack.Pop(); } var greaterThan = Match(SyntaxKind.GreaterThanToken); var typeArgumentList = new TemplateArgumentListSyntax(lessThan, new SeparatedSyntaxList <ExpressionSyntax>(new List <SyntaxNodeBase> { userDefinedType, comma, controlPoints }), greaterThan); return(new PredefinedObjectTypeSyntax(token, typeArgumentList)); }
private ExpressionSyntax ParseVariableInitializer() { CommaIsSeparatorStack.Push(true); try { switch (Current.Kind) { case SyntaxKind.OpenBraceToken: return(ParseArrayInitializer()); default: return(ParseExpression()); } } finally { CommaIsSeparatorStack.Pop(); } }
private ExpressionSyntax ParseCastOrParenthesizedExpression() { Debug.Assert(Current.Kind == SyntaxKind.OpenParenToken); var resetPoint = GetResetPoint(); // We have a decision to make -- is this a cast, or is it a parenthesized // expression? Because look-ahead is cheap with our token stream, we check // to see if this "looks like" a cast (without constructing any parse trees) // to help us make the decision. if (ScanCast()) { // Looks like a cast, so parse it as one. Reset(ref resetPoint); var openParen = Match(SyntaxKind.OpenParenToken); List <ArrayRankSpecifierSyntax> arrayRankSpecifiers; var type = ParseTypeForCast(out arrayRankSpecifiers); var closeParen = Match(SyntaxKind.CloseParenToken); var expr = ParseSubExpression(SyntaxFacts.GetOperatorPrecedence(SyntaxKind.CastExpression)); return(new CastExpressionSyntax(openParen, type, arrayRankSpecifiers, closeParen, expr)); } // Doesn't look like a cast, so parse this as a parenthesized expression. { Reset(ref resetPoint); var openParen = Match(SyntaxKind.OpenParenToken); try { CommaIsSeparatorStack.Push(false); var expression = ParseSubExpression(0); var closeParen = Match(SyntaxKind.CloseParenToken); return(new ParenthesizedExpressionSyntax(openParen, expression, closeParen)); } finally { CommaIsSeparatorStack.Pop(); } } }
private PredefinedObjectTypeSyntax ParseMultisampledTextureType(SyntaxToken token) { var lessThan = Match(SyntaxKind.LessThanToken); var type = ParseScalarOrVectorType(); var arguments = new List <SyntaxNodeBase> { type }; if (Current.Kind == SyntaxKind.CommaToken) { var comma = Match(SyntaxKind.CommaToken); ExpressionSyntax samples; try { CommaIsSeparatorStack.Push(true); _greaterThanTokenIsNotOperator = true; samples = ParseExpression(); } finally { _greaterThanTokenIsNotOperator = false; CommaIsSeparatorStack.Pop(); } arguments.Add(comma); arguments.Add(samples); } var greaterThan = Match(SyntaxKind.GreaterThanToken); var typeArgumentList = new TemplateArgumentListSyntax(lessThan, new SeparatedSyntaxList <ExpressionSyntax>(arguments), greaterThan); return(new PredefinedObjectTypeSyntax(token, typeArgumentList)); }
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); }