private ExpressionSyntax ParsePrimary()
{
var k = this.CurrentToken.Kind;
switch (k)
{
case SyntaxKind.OpenParenToken:
var open = this.EatToken();
var expr = this.ParseExpression();
var close = this.EatToken(SyntaxKind.CloseParenToken);
return(SyntaxFactory.ParenthesizedExpression(open, expr, close));
case SyntaxKind.IdentifierToken:
var identifier = TruncateIdentifier(this.EatToken());
return(SyntaxFactory.IdentifierName(identifier));
case SyntaxKind.TrueKeyword:
case SyntaxKind.FalseKeyword:
return(SyntaxFactory.LiteralExpression(
SyntaxFacts.GetLiteralExpression(k),
this.EatToken()
));
default:
return(SyntaxFactory.IdentifierName(
this.EatToken(SyntaxKind.IdentifierToken, ErrorCode.ERR_InvalidPreprocExpr)
));
}
}
private ExpressionSyntax ParseDirectiveTerm()
{
ExpressionSyntax expr;
var tk = Current.Kind;
switch (tk)
{
case SyntaxKind.IdentifierToken:
expr = ParseIdentifier();
break;
case SyntaxKind.FalseKeyword:
case SyntaxKind.TrueKeyword:
case SyntaxKind.IntegerLiteralToken:
case SyntaxKind.FloatLiteralToken:
expr = new LiteralExpressionSyntax(SyntaxFacts.GetLiteralExpression(Current.Kind), NextToken());
break;
case SyntaxKind.OpenParenToken:
expr = ParseDirectiveParenthesizedExpression();
break;
default:
expr = CreateMissingIdentifierName();
if (tk == SyntaxKind.EndOfFileToken)
{
expr = WithDiagnostic(expr, DiagnosticId.ExpressionExpected);
}
else
{
expr = WithDiagnostic(expr, DiagnosticId.InvalidExprTerm, tk.GetText());
}
break;
}
// Might be function invocation. We only have one function in the preprocessor - "defined".
if (Current.Kind == SyntaxKind.OpenParenToken && expr.Kind == SyntaxKind.IdentifierName &&
((IdentifierNameSyntax)expr).Name.ContextualKind == SyntaxKind.DefinedKeyword)
{
_lexer.ExpandMacros = false;
var openParen = Match(SyntaxKind.OpenParenToken);
var name = new IdentifierNameSyntax(NextToken());
_lexer.ExpandMacros = true;
var closeParen = Match(SyntaxKind.CloseParenToken);
expr = new FunctionInvocationExpressionSyntax((IdentifierNameSyntax)expr, new ArgumentListSyntax(
openParen,
new SeparatedSyntaxList <ExpressionSyntax>(new List <SyntaxNodeBase> {
name
}),
closeParen));
}
return(expr);
}
private ExpressionSyntax ParseTerm()
{
ExpressionSyntax expr;
var tk = Current.Kind;
switch (tk)
{
case SyntaxKind.FalseKeyword:
case SyntaxKind.TrueKeyword:
case SyntaxKind.IntegerLiteralToken:
case SyntaxKind.FloatLiteralToken:
expr = new LiteralExpressionSyntax(SyntaxFacts.GetLiteralExpression(Current.Kind), NextToken());
break;
default:
expr = new EnumNameExpressionSyntax(new List <SyntaxToken> {
InsertMissingToken(SyntaxKind.IdentifierToken)
});
if (tk == SyntaxKind.EndOfFileToken)
{
expr = WithDiagnostic(expr, DiagnosticId.ExpressionExpected);
}
else
{
expr = WithDiagnostic(expr, DiagnosticId.InvalidExprTerm, tk.GetText());
}
break;
}
return(expr);
}
public SyntaxKind GetKind()
{
if (Kind != SyntaxKind.None)
{
return(Kind);
}
return(SyntaxFacts.GetLiteralExpression(TameSyntaxFacts.SyntaxKindFromStr(TokenStr)));
}
public void SyntaxFactsMethods()
{
Assert.AreEqual("protected internal", SyntaxFacts.GetText(Accessibility.ProtectedOrInternal));
Assert.AreEqual("??", SyntaxFacts.GetText(SyntaxKind.QuestionQuestionToken));
Assert.AreEqual("this", SyntaxFacts.GetText(SyntaxKind.ThisKeyword));
Assert.AreEqual(SyntaxKind.CharacterLiteralExpression, SyntaxFacts.GetLiteralExpression(SyntaxKind.CharacterLiteralToken));
Assert.AreEqual(SyntaxKind.CoalesceExpression, SyntaxFacts.GetBinaryExpression(SyntaxKind.QuestionQuestionToken));
Assert.AreEqual(SyntaxKind.None, SyntaxFacts.GetBinaryExpression(SyntaxKind.UndefDirectiveTrivia));
Assert.AreEqual(false, SyntaxFacts.IsPunctuation(SyntaxKind.StringLiteralToken));
}
public void TestPrimaryExpressions(SyntaxKind kind)
{
var text = kind.GetText();
var expr = ParseExpression(text);
Assert.NotNull(expr);
var opKind = SyntaxFacts.GetLiteralExpression(kind);
Assert.Equal(opKind, expr.Kind);
Assert.Equal(0, expr.GetDiagnostics().Count());
var us = (LiteralExpressionSyntax)expr;
Assert.NotNull(us.Token);
Assert.Equal(kind, us.Token.Kind);
}
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 ParseTerm(Precedence precedence)
{
ExpressionSyntax expr = null;
var tk = CurrentToken.Kind;
switch (tk)
{
case SyntaxKind.IdentifierToken:
expr = SyntaxFactory.IdentifierName(ParseIdentifierToken());
break;
case SyntaxKind.NumericLiteralToken:
case SyntaxKind.StringLiteralToken:
expr = SyntaxFactory.LiteralExpression(SyntaxFacts.GetLiteralExpression(tk), EatToken(tk));
break;
default:
expr = CreateMissingIdentifierName();
break;
}
return(expr);
}
private ExpressionSyntax ParseTerm()
{
ExpressionSyntax expr;
var tk = Current.Kind;
switch (tk)
{
case SyntaxKind.IdentifierToken:
expr = ParseIdentifierOrFunctionInvocationExpression();
break;
case SyntaxKind.FalseKeyword:
case SyntaxKind.TrueKeyword:
case SyntaxKind.IntegerLiteralToken:
case SyntaxKind.FloatLiteralToken:
expr = new LiteralExpressionSyntax(SyntaxFacts.GetLiteralExpression(Current.Kind), NextToken());
break;
case SyntaxKind.StringLiteralToken:
{
var stringTokens = new List <SyntaxToken> {
NextToken()
};
while (Current.Kind == SyntaxKind.StringLiteralToken)
{
stringTokens.Add(NextToken());
}
expr = new StringLiteralExpressionSyntax(stringTokens);
break;
}
case SyntaxKind.OpenParenToken:
expr = ParseCastOrParenthesizedExpression();
break;
default:
if (_allowLinearAndPointAsIdentifiers && (tk == SyntaxKind.LinearKeyword || tk == SyntaxKind.PointKeyword))
{
goto case SyntaxKind.IdentifierToken;
}
if ((SyntaxFacts.IsPredefinedScalarType(tk) && tk != SyntaxKind.UnsignedKeyword && tk != SyntaxKind.VoidKeyword) || SyntaxFacts.IsPredefinedVectorType(tk) || SyntaxFacts.IsPredefinedMatrixType(tk))
{
if (Lookahead.Kind == SyntaxKind.OpenParenToken)
{
expr = ParseNumericConstructorInvocationExpression();
break;
}
}
expr = CreateMissingIdentifierName();
if (tk == SyntaxKind.EndOfFileToken)
{
expr = WithDiagnostic(expr, DiagnosticId.ExpressionExpected);
}
else
{
expr = WithDiagnostic(expr, DiagnosticId.InvalidExprTerm, tk.GetText());
}
break;
}
return(ParsePostFixExpression(expr));
}
public void TestGetLiteralExpression(SyntaxKind tokenKind, SyntaxKind expressionKind)
{
Assert.Equal(expressionKind, SyntaxFacts.GetLiteralExpression(tokenKind));
}
