public static ExpressionToken Operator(SyntaxTokenKind operation)
{
return(new ExpressionToken()
{
Operation = operation
});
}
public static bool TryGetUnaryOperatorKind(SyntaxTokenKind operatorTokenKind, out UnaryOperatorKind kind)
{
switch (operatorTokenKind)
{
case SyntaxTokenKind.Exclamation:
kind = UnaryOperatorKind.Not;
break;
case SyntaxTokenKind.Plus:
kind = UnaryOperatorKind.Plus;
break;
case SyntaxTokenKind.Minus:
kind = UnaryOperatorKind.Minus;
break;
case SyntaxTokenKind.At:
kind = UnaryOperatorKind.Delta;
break;
default:
kind = default;
return(false);
}
return(true);
}
public void Dialogue_Block_Tag(string text, SyntaxTokenKind kind)
{
(SyntaxToken token, LexingContext ctx) = LexToken(text);
Assert.Equal(kind, token.Kind);
Assert.Equal(text, ctx.GetText(token).ToString());
Assert.Equal(SyntaxTokenFlags.Empty, token.Flags);
}
public static SyntaxTokenKind GetKeywordKind(string keyword)
{
SyntaxTokenKind kind = SyntaxTokenKind.None;
s_keywords.TryGetValue(keyword.ToLowerInvariant(), out kind);
return(kind);
}
internal SyntaxToken(SourceLocation location, SyntaxTokenKind kind, string text, object?value,
ImmutableArray <SyntaxTrivia> leading, ImmutableArray <SyntaxTrivia> trailing,
ImmutableArray <SyntaxDiagnostic> diagnostics)
{
Location = location;
Kind = kind;
Text = text;
Value = value;
LeadingTrivia = leading;
TrailingTrivia = trailing;
Diagnostics = diagnostics;
if (HasLeadingTrivia)
{
foreach (var trivia in leading)
{
trivia.Parent = this;
}
}
if (HasTrailingTrivia)
{
foreach (var trivia in trailing)
{
trivia.Parent = this;
}
}
}
private static BoundBinaryOperator BindBinaryOperator(SyntaxTokenKind op)
{
switch (op)
{
case SyntaxTokenKind.Plus: return(BoundBinaryOperator.Addition);
case SyntaxTokenKind.Minus: return(BoundBinaryOperator.Subtraction);
case SyntaxTokenKind.Star: return(BoundBinaryOperator.Multiplication);
case SyntaxTokenKind.Slash: return(BoundBinaryOperator.Division);
case SyntaxTokenKind.StarStar: return(BoundBinaryOperator.Power);
case SyntaxTokenKind.SlashSlah: return(BoundBinaryOperator.Root);
case SyntaxTokenKind.Percentage: return(BoundBinaryOperator.Modulo);
case SyntaxTokenKind.Ampersand: return(BoundBinaryOperator.BitwiseAnd);
case SyntaxTokenKind.Pipe: return(BoundBinaryOperator.BitwiseOr);
case SyntaxTokenKind.Hat: return(BoundBinaryOperator.BitwiseXor);
case SyntaxTokenKind.EqualEqual: return(BoundBinaryOperator.EqualEqual);
case SyntaxTokenKind.NotEqual: return(BoundBinaryOperator.NotEqual);
case SyntaxTokenKind.LessThan: return(BoundBinaryOperator.LessThan);
case SyntaxTokenKind.LessEqual: return(BoundBinaryOperator.LessEqual);
case SyntaxTokenKind.GreaterThan: return(BoundBinaryOperator.GreaterThan);
case SyntaxTokenKind.GreaterEqual: return(BoundBinaryOperator.GreaterEqual);
case SyntaxTokenKind.AmpersandAmpersand: return(BoundBinaryOperator.LogicalAnd);
case SyntaxTokenKind.PipePipe: return(BoundBinaryOperator.LogicalOr);
case SyntaxTokenKind.PlusEqual: return(BoundBinaryOperator.Addition);
case SyntaxTokenKind.MinusEqual: return(BoundBinaryOperator.Subtraction);
case SyntaxTokenKind.StarEqual: return(BoundBinaryOperator.Multiplication);
case SyntaxTokenKind.SlashEqual: return(BoundBinaryOperator.Division);
case SyntaxTokenKind.AmpersandEqual: return(BoundBinaryOperator.BitwiseAnd);
case SyntaxTokenKind.PipeEqual: return(BoundBinaryOperator.BitwiseOr);
case SyntaxTokenKind.PlusPlus: return(BoundBinaryOperator.Addition);
case SyntaxTokenKind.MinusMinus: return(BoundBinaryOperator.Subtraction);
default: return(BoundBinaryOperator.Invalid);
}
}
public void Recognizes_Certain_Quoted_Keywords(SyntaxTokenKind keyword)
{
string quotedText = $"\"{SyntaxFacts.GetText(keyword)}\"";
(SyntaxToken token, LexingContext ctx) = LexToken(quotedText);
Assert.Equal(keyword, token.Kind);
Assert.Equal(SyntaxTokenFlags.IsQuoted, token.Flags);
}
public static void LexAllTokens(string text, SyntaxTokenKind kind)
{
var tokens = SyntaxTree.Tokenize(new SourceText(text, null));
Assert.Equal(2, tokens.Length);
Assert.Equal(kind, tokens[0].TokenKind);
Assert.Equal(SyntaxTokenKind.EndOfFile, tokens[1].TokenKind);
}
public void StaticToken(SyntaxTokenKind kind, string text)
{
(SyntaxToken token, LexingContext ctx) = LexToken(text);
Assert.Equal(kind, token.Kind);
Assert.Equal(text, SyntaxFacts.GetText(kind));
Assert.Equal(text, ctx.GetText(token).ToString(), ignoreCase: true);
Assert.Equal(SyntaxTokenFlags.Empty, token.Flags);
}
private SyntaxToken EatToken(SyntaxTokenKind expectedKind)
{
if (CurrentToken.Kind != expectedKind)
{
throw ExceptionUtilities.UnexpectedToken(FileName, CurrentToken.Text);
}
return(_tokens[_tokenOffset++]);
}
public static bool IsInTokenGroup(this SyntaxTokenKind kind, SyntaxTokenGroup @group)
{
if (_groupLookup.Value.Contains(group))
{
return(_groupLookup.Value[group].Contains(kind));
}
return(false);
}
public static int GetBinaryOperationPrecedence(this SyntaxTokenKind kind)
{
if (_precedenceDictionary.Value.ContainsKey(kind))
{
return(_precedenceDictionary.Value[kind]);
}
return(0);
}
public void Literal(string text, SyntaxTokenKind tokenKind, string valueText,
SyntaxTokenFlags flags = SyntaxTokenFlags.Empty)
{
(SyntaxToken token, LexingContext ctx) = LexToken(text);
Assert.Equal(tokenKind, token.Kind);
Assert.Equal(text, ctx.GetText(token).ToString());
Assert.Equal(valueText, ctx.GetValueText(token).ToString());
Assert.Equal(flags, token.Flags);
}
protected SyntaxToken Match(SyntaxTokenKind kind)
{
if (_current.Kind == kind)
{
return(Next());
}
_diagnostics.ReportUnexpectedToken(kind, _current);
return(SyntaxToken.Manufacture(kind, _current.Position));
}
private SyntaxToken(SyntaxTokenKind kind, int position)
{
if (position < 0)
{
throw new ArgumentOutOfRangeException(nameof(position));
}
Kind = kind;
Position = position;
Text = string.Empty;
}
public static bool IsPostfixUnaryOperator(SyntaxTokenKind tokenKind)
{
switch (tokenKind)
{
case SyntaxTokenKind.PlusPlusToken:
case SyntaxTokenKind.MinusMinusToken:
return(true);
default:
return(false);
}
}
private SyntaxToken MatchToken(SyntaxTokenKind kind)
{
if (_tokens.Current.Kind == kind)
{
var current = _tokens.Current;
_tokens.MoveNext();
return(current);
}
_diagnostics.ReportError(DiagnosticKind.UnexpectedToken, _tokens.Current.StartIndex, _tokens.Current.Text.Length, kind, _tokens.Current.Kind);
_tokens.MoveNext();
return(new SyntaxToken(kind, 0, null));
}
private StatementSyntax ParseProcedureStatement(SyntaxTokenKind kind)
{
var modifier = TryNext(SyntaxTokenKind.Star);
var keyword = Match(kind);
var openParenthesis = TryNext(SyntaxTokenKind.OpenParenthesis);
var arguments = ParseArguments(openParenthesis != null, 0);
var closeParenthesis = openParenthesis != null?Match(SyntaxTokenKind.CloseParenthesis) : null;
var endOfLineToken = MatchEndOfStatement();
return(new ProcedureStatementSyntax(modifier, keyword, openParenthesis, arguments, closeParenthesis, endOfLineToken));
}
public SyntaxToken(SyntaxTokenKind kind, int position, string text) : this(kind, position)
{
if (kind.HasValue())
{
throw new AggregateException($"Token with kind '{kind}' should contain value.");
}
if (string.IsNullOrEmpty(text))
{
throw new ArgumentException("Token text cannot be null or empty.", nameof(text));
}
Text = text;
}
public SyntaxToken ExpectToken(SyntaxTokenKind kind, int offset = 0)
{
bool match = MatchToken(kind, offset);
if (match == false)
{
Error(Errors.UnexpectedToken(CurrentToken, kind));
return(SyntaxToken.Invalid);
}
return(PeekBack());
}
public void TokenPair(SyntaxTokenKind t1Kind, string t1Text, SyntaxTokenKind t2Kind, string t2Text)
{
string text = t1Text + t2Text;
(SyntaxTokenEnumerable tkEnumerable, LexingContext ctx) = Parsing.LexTokens(text);
var tokens = tkEnumerable.ToArray();
Assert.Equal(3, tokens.Length);
Assert.Equal(tokens[0].Kind, t1Kind);
Assert.Equal(ctx.GetText(tokens[0]).ToString(), t1Text, ignoreCase: true);
Assert.Equal(tokens[1].Kind, t2Kind);
Assert.Equal(ctx.GetText(tokens[1]).ToString(), t2Text, ignoreCase: true);
}
public static bool CanStartDeclaration(SyntaxTokenKind tokenKind)
{
switch (tokenKind)
{
case SyntaxTokenKind.ChapterKeyword:
case SyntaxTokenKind.SceneKeyword:
case SyntaxTokenKind.FunctionKeyword:
return(true);
default:
return(false);
}
}
public static string GetText(SyntaxTokenKind kind)
{
switch (kind)
{
case SyntaxTokenKind.ChapterKeyword:
return("chapter");
case SyntaxTokenKind.FunctionKeyword:
return("function");
case SyntaxTokenKind.SceneKeyword:
return("scene");
case SyntaxTokenKind.CallSceneKeyword:
return("call_scene");
case SyntaxTokenKind.CallChapterKeyword:
return("call_chapter");
case SyntaxTokenKind.NullKeyword:
return("null");
case SyntaxTokenKind.TrueKeyword:
return("true");
case SyntaxTokenKind.FalseKeyword:
return("false");
case SyntaxTokenKind.WhileKeyword:
return("while");
case SyntaxTokenKind.IfKeyword:
return("if");
case SyntaxTokenKind.ElseKeyword:
return("else");
case SyntaxTokenKind.SelectKeyword:
return("select");
case SyntaxTokenKind.CaseKeyword:
return("case");
case SyntaxTokenKind.BreakKeyword:
return("break");
default:
return(string.Empty);
}
}
public void AssertToken(SyntaxTokenKind kind, string text)
{
try
{
Assert.True(enumerator.MoveNext());
var token = Assert.IsType <SyntaxToken>(enumerator.Current);
Assert.Equal(kind, token.TokenKind);
Assert.Equal(text, token.Location.ToString());
}
catch when(MarkFailed())
{
throw;
}
}
internal static bool IsLiteralExpression(this SyntaxTokenKind kind)
{
switch (kind)
{
case SyntaxTokenKind.Float:
case SyntaxTokenKind.Int:
case SyntaxTokenKind.String:
case SyntaxTokenKind.True:
case SyntaxTokenKind.False:
return(true);
default: return(false);
}
}
public SyntaxToken(SyntaxTokenKind kind, int position, string text, object value) : this(kind, position)
{
if (!kind.HasValue())
{
throw new AggregateException($"Token with kind '{kind}' can't contain value.");
}
if (string.IsNullOrEmpty(text))
{
throw new ArgumentException("Token text cannot be null or empty.", nameof(text));
}
Value = value ?? throw new ArgumentNullException(nameof(value));
Text = text;
}
public static UnaryOperationKind GetPostfixUnaryOperationKind(SyntaxTokenKind operatorTokenKind)
{
switch (operatorTokenKind)
{
case SyntaxTokenKind.PlusPlusToken:
return(UnaryOperationKind.PostfixIncrement);
case SyntaxTokenKind.MinusMinusToken:
return(UnaryOperationKind.PostfixDecrement);
default:
throw new ArgumentException(nameof(operatorTokenKind));
}
}
internal static bool IsTypeKeyword(this SyntaxTokenKind kind)
{
switch (kind)
{
case SyntaxTokenKind.IntKeyword:
case SyntaxTokenKind.FloatKeyword:
case SyntaxTokenKind.BoolKeyword:
case SyntaxTokenKind.StringKeyword:
case SyntaxTokenKind.ObjKeyword:
case SyntaxTokenKind.VoidKeyword:
return(true);
default: return(false);
}
}
public static List <SyntaxTokenKind> ConvertToSyntaxTokenKinds(string input)
{
List <SyntaxTokenKind> tokenKinds = new List <SyntaxTokenKind>();
string[] tokenKindStrArray = input.Split(",");
foreach (string tokenKindName in tokenKindStrArray)
{
if (SyntaxTokenKind.TryParse(tokenKindName, out SyntaxTokenKind tokenKind))
{
tokenKinds.Add(tokenKind);
}
}
return(tokenKinds);
}
private static BoundUnaryOperator BindUnaryOperator(SyntaxTokenKind op)
{
switch (op)
{
case SyntaxTokenKind.Plus: return(BoundUnaryOperator.Identety);
case SyntaxTokenKind.Minus: return(BoundUnaryOperator.Negation);
case SyntaxTokenKind.Bang: return(BoundUnaryOperator.LogicalNot);
case SyntaxTokenKind.Tilde: return(BoundUnaryOperator.BitwiseNot);
default: return(BoundUnaryOperator.Invalid);
}
}
private SyntaxToken(SyntaxTokenKind kind)
{
_kind = kind;
}