public Token(string value, TokenType type, LiteralTokenType literalType, ISourceLocation source)
{
Type = type;
LiteralType = literalType;
Value = value;
if (source != null)
{
Line = source.Line;
Column = source.Column - (value?.Length ?? 0);
}
}
static TDataType ConvertToDataType <TDataType>(LiteralTokenType tokenType)
where TDataType : class, IDataType <DataType>
{
ILiteralToken literalToken = TestCommon.MakeLiteralToken(tokenType);
var dataType = ((ICalcEngine)CalcEngine.Instance).ConvertToDataType(literalToken, null);
dataType.Should().NotBeNull();
dataType.Should().BeOfType <TDataType>();
var typedDataType = dataType as TDataType;
typedDataType.Should().NotBeNull();
return(typedDataType);
}
static TToken MakeToken <TToken>(LiteralTokenType tokenType, string value = "")
where TToken : class, ILiteralToken
{
var token = string.IsNullOrWhiteSpace(value)
? TestCommon.MakeLiteralToken(tokenType)
: TestCommon.MakeLiteralToken(tokenType, value);
token.Should().NotBeNull();
token.Should().BeOfType <TToken>();
var typedToken = token as TToken;
typedToken.Should().NotBeNull();
return(typedToken);
}
public static ILiteralToken MakeLiteralToken(this LiteralTokenType tokenType, string value = null)
{
switch (tokenType)
{
case LiteralTokenType.Date:
return(string.IsNullOrEmpty(value)
? DateToken.Now
: MakeLiteralToken($"date {value}"));
case LiteralTokenType.Float:
return(string.IsNullOrEmpty(value)
? FloatToken.One
: MakeLiteralToken($"float {value}"));
case LiteralTokenType.LimitedInteger:
return(string.IsNullOrEmpty(value)
? LimitedIntegerToken.One
: MakeLiteralToken($"limitedinteger {value}"));
case LiteralTokenType.Time:
return(string.IsNullOrEmpty(value)
? TimeToken.One
: MakeLiteralToken($"time {value}"));
case LiteralTokenType.Timespan:
return(string.IsNullOrEmpty(value)
? TimespanToken.One
: MakeLiteralToken($"timespan {value}"));
case LiteralTokenType.UnlimitedInteger:
return(string.IsNullOrEmpty(value)
? UnlimitedIntegerToken.One
: MakeLiteralToken($"unlimitedinteger {value}"));
default:
throw new TestOperationException($"Unsupported literal token type {tokenType}");
}
}
internal LiteralToken(LiteralTokenType literalType, string sourcePath, BufferPosition position)
: base(TokenType.Literal, sourcePath, position)
{
_literalType = literalType;
}
protected LiteralToken(LiteralTokenType literalTokenType, TBaseType typedValue, string rawToken, SourcePosition position)
: base(rawToken, position)
{
LiteralType = literalTokenType;
TypedValue = typedValue;
}
internal LiteralToken(LiteralTokenType literalType, string sourcePath, BufferPosition position)
: base(TokenType.Literal, sourcePath, position)
{
_literalType = literalType;
}
/// <summary>
/// Creates a string literal token with a given <paramref name="value"/>.
/// </summary>
/// <param name="value">The value to associate with this token.</param>
/// <param name="literalType">The <see cref="LiteralTokenType"/> of this <see cref="Token"/>.</param>
/// <param name="location">The <see cref="ISourceLocation"/> of this <see cref="Token"/>, used for exception generation purposes.</param>
/// <returns>A string literal token with the given value.</returns>
public static Token LiteralValue(string value, LiteralTokenType literalType, ISourceLocation location)
{
return(new Token(value, TokenType.LiteralValue, literalType, location));
}
