public LiteralValueNode ParseLitealValue(Token token)
{
if (token.Type == TokenType.LiteralValue)
{
LiteralValueNode value = null;
CobaltType cobaltType = token.GetData <CobaltType>(TokenDataKeys.COBALT_TYPE);
switch (cobaltType)
{
case CobaltType.Boolean:
value = new BooleanValueNode(token.SourceLine, token.GetData <bool>(TokenDataKeys.LITERAL_VALUE));
break;
case CobaltType.Float:
value = new FloatValueNode(token.SourceLine, token.GetData <float>(TokenDataKeys.LITERAL_VALUE));
break;
case CobaltType.Integer:
value = new IntegerValueNode(token.SourceLine, token.GetData <int>(TokenDataKeys.LITERAL_VALUE));
break;
default:
throw new CompilerException($"`{MethodBase.GetCurrentMethod().Name}` called with unknown Cobalt type `{cobaltType}`.");
}
return(value);
}
else
{
throw new CompilerException($"`{MethodBase.GetCurrentMethod().Name}` called with a bad token. Expected a token of type `{TokenType.LiteralValue}`, got token of type `{token.Type}` instead.");
}
}
public void ShouldParseLiteralValues(object value, CobaltType type)
{
// Arrange
Token token = new Token(TokenType.LiteralValue, 1, 0);
token.SetData(TokenDataKeys.LITERAL_VALUE, value);
token.SetData(TokenDataKeys.COBALT_TYPE, type);
// Act
LiteralValueNode node = Parser.ParseLitealValue(token);
// Assert
switch (type)
{
case CobaltType.Boolean:
if (node is BooleanValueNode booleanValue)
{
Assert.Equal((bool)value, booleanValue.Value);
}
else
{
throw new XunitException("Wrong Cobalt type.");
}
break;
case CobaltType.Float:
if (node is FloatValueNode floatValue)
{
Assert.Equal((float)value, floatValue.Value);
}
else
{
throw new XunitException("Wrong Cobalt type.");
}
break;
case CobaltType.Integer:
if (node is IntegerValueNode integerValue)
{
Assert.Equal((int)value, integerValue.Value);
}
else
{
throw new XunitException("Wrong Cobalt type.");
}
break;
default:
throw new XunitException("No test implemented for this type.");
}
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
foreach (var childNode in treeNode.ChildNodes)
{
if (childNode.AstNode is IdentifierNode)
{
Identifier = childNode.AstNode as IdentifierNode;
}
else if (childNode.AstNode is LiteralValueNode)
{
Value = childNode.AstNode as LiteralValueNode;
}
}
AsString = string.Join(" ", "const", Identifier, "=", Value);
}
private void GenerateLiteralValueCode(StringBuilder builder, LiteralValueNode literalValue)
{
switch (literalValue)
{
case BooleanValueNode booleanValue:
builder.Append(booleanValue.Value);
break;
case FloatValueNode floatValue:
builder.Append(floatValue.Value);
break;
case IntegerValueNode integerValue:
builder.Append(integerValue.Value);
break;
default:
throw new CompilerException($"`{MethodBase.GetCurrentMethod().Name}` called with bad AST stucture. Expected a literal value node.");
}
}
private string GetExpression(LiteralValueNode litValueNode)
{
var value = litValueNode.Value;
return(ObjectReference(value));
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
Route = ((LiteralValueNode)treeNode.ChildNodes.Last().AstNode);
}
