private void SetNumericalExpression(IdentifierValueNode identifierValueNode,
ExpressionNode expressionNode, SymbolType expressionType)
{
switch (expressionType)
{
case SymbolType.Float:
{
FloatValueNode floatValueNode = new FloatValueNode();
ExpressionEvaluator <float> expressionEvaluator = new ExpressionEvaluator <float>(new FloatCalculator(expressionNode.Token));
expressionNode.Accept(expressionEvaluator);
floatValueNode.Value = expressionEvaluator.Result;
identifierValueNode.ValueNode = floatValueNode;
break;
}
case SymbolType.Integer:
{
IntValueNode intValueNode = new IntValueNode();
ExpressionEvaluator <int> expressionEvaluator = new ExpressionEvaluator <int>(new IntCalculator(expressionNode.Token));
expressionNode.Accept(expressionEvaluator);
intValueNode.Value = expressionEvaluator.Result;
identifierValueNode.ValueNode = intValueNode;
break;
}
}
}
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 override IValueNode ParseValue(IType type, object?value)
{
if (type is null)
{
throw new ArgumentNullException(nameof(type));
}
if (value is null)
{
return(NullValueNode.Default);
}
if (!(value is Coordinate coordinate))
{
throw ThrowHelper.PositionScalar_CoordinatesCannotBeNull(null !);
}
var xNode = new FloatValueNode(coordinate.X);
var yNode = new FloatValueNode(coordinate.Y);
if (!double.IsNaN(coordinate.Z))
{
var zNode = new FloatValueNode(coordinate.Z);
return(new ListValueNode(xNode, yNode, zNode));
}
return(new ListValueNode(xNode, yNode));
}
/// input value from the client
public override IValueNode ParseValue(object?value)
{
// parse Coordinate into literal
if (value is null)
{
return(new NullValueNode(null));
}
if (!(value is Coordinate coordinate))
{
throw ThrowHelper.InvalidType();
}
var xNode = new FloatValueNode(coordinate.X);
var yNode = new FloatValueNode(coordinate.Y);
// third optional element (z/elevation)
if (!double.IsNaN(coordinate.Z))
{
var zNode = new FloatValueNode(coordinate.Z);
return(new ListValueNode(xNode, yNode, zNode));
}
return(new ListValueNode(xNode, yNode));
}
public void ParseLiteral_Wrong_ValueNode_Throws()
{
// arrange
var type = new IdType();
FloatValueNode input = new FloatValueNode("123456");
// act
// assert
Assert.Throws <ArgumentException>(() => type.ParseLiteral(input));
}
public void ParseLiteral_Wrong_ValueNode_Throws()
{
// arrange
var type = new IdType();
var input = new FloatValueNode("123456");
// act
// assert
Assert.Throws <ScalarSerializationException>(
() => type.ParseLiteral(input));
}
public void ParseValue_Nullable()
{
// arrange
var type = new DecimalType();
decimal?input = 123M;
// act
FloatValueNode output = (FloatValueNode)type.ParseValue(input);
// assert
Assert.Equal(123M, output.ToDecimal());
}
public void IsInstanceOfType_Wrong_ValueNode()
{
// arrange
var type = new IdType();
var input = new FloatValueNode("123456");
// act
bool result = type.IsInstanceOfType(input);
// assert
Assert.False(result);
}
public void ParseValue_Nullable()
{
// arrange
var type = new FloatType();
double?input = 123;
// act
FloatValueNode output = (FloatValueNode)type.ParseValue(input);
// assert
Assert.Equal(123, output.ToDouble());
}
public void ParseLiteral_FixedPointLiteral()
{
// arrange
var type = new DecimalType();
FloatValueNode literal = CreateFixedPointLiteral();
// act
var value = type.ParseLiteral(literal);
// assert
Assert.IsType <decimal>(value);
Assert.Equal(literal.ToDecimal(), value);
}
public void ParseLiteral_ExponentialLiteral()
{
// arrange
var type = new FloatType();
FloatValueNode literal = CreateExponentialLiteral();
// act
var value = type.ParseLiteral(literal);
// assert
Assert.IsType <double>(value);
Assert.Equal(literal.ToDouble(), value);
}
public void ParseLiteral_FloatValueNode()
{
// arrange
FloatType type = new FloatType();
FloatValueNode input = new FloatValueNode("1.000000e+000");
// act
object output = type.ParseLiteral(input);
// assert
Assert.IsType <double>(output);
Assert.Equal(1.0d, output);
}
public void ParseValue_Decimal_Min()
{
// arrange
DecimalType type = new DecimalType();
decimal input = decimal.MinValue;
string expectedLiteralValue = "-7.922816e+028";
// act
FloatValueNode literal =
(FloatValueNode)type.ParseValue(input);
// assert
Assert.Equal(expectedLiteralValue, literal.Value, StringComparer.InvariantCulture);
}
protected override void VisitFloatValue(
FloatValueNode node,
Action <object> setValue)
{
if (double.TryParse(node.Value, NumberStyles.Float,
CultureInfo.InvariantCulture, out double d))
{
setValue(d);
}
else
{
setValue(node.Value);
}
}
public void ParseValue_Double()
{
// arrange
FloatType type = new FloatType();
double input = 1.0d;
string expectedLiteralValue = "1.000000e+000";
// act
FloatValueNode literal =
(FloatValueNode)type.ParseValue(input);
// assert
Assert.Equal(expectedLiteralValue, literal.Value);
}
public override IValueNode ParseResult(IType type, object?resultValue)
{
if (type is null)
{
throw new ArgumentNullException(nameof(type));
}
if (resultValue is null)
{
return(NullValueNode.Default);
}
if (resultValue is Coordinate coords)
{
if (coords.Z is double.NaN)
{
return(new ListValueNode(
new FloatValueNode(coords.X),
new FloatValueNode(coords.Y)));
}
return(new ListValueNode(
new FloatValueNode(coords.X),
new FloatValueNode(coords.Y),
new FloatValueNode(coords.Z)));
}
if (resultValue is not double[] coordinate)
{
throw ThrowHelper.PositionScalar_CoordinatesCannotBeNull(null !);
}
if (coordinate.Length != 2 && coordinate.Length != 3)
{
throw ThrowHelper.PositionScalar_InvalidPositionObject(null !);
}
var xNode = new FloatValueNode(coordinate[0]);
var yNode = new FloatValueNode(coordinate[1]);
if (coordinate.Length > 2)
{
var zNode = new FloatValueNode(coordinate[2]);
return(new ListValueNode(xNode, yNode, zNode));
}
return(new ListValueNode(xNode, yNode));
}
public static void WriteFloatValue(this ISyntaxWriter writer, FloatValueNode node)
{
writer.Write(node.Value);
}
public abstract void Visit(FloatValueNode node);
public void Visit(AssignmentNode assignmentNode)
{
SymbolType expressionType = new ExpressionTypeChecker(CurrentScope).GetType(assignmentNode.Expression);
ValueNode expressionValue;
switch (expressionType)
{
case SymbolType.Null:
expressionValue = null;
break;
case SymbolType.Float:
var floatEval = new ExpressionEvaluator <float>(new FloatCalculator(assignmentNode.Token));
assignmentNode.Expression.Accept(floatEval);
expressionValue = new FloatValueNode()
{
Value = floatEval.Result
};
break;
case SymbolType.String:
var stringEval = new ExpressionEvaluator <string>(new StringOperations(assignmentNode.Token));
assignmentNode.Expression.Accept(stringEval);
expressionValue = new StringNode()
{
Value = stringEval.Result
};
break;
case SymbolType.Integer:
var intEval = new ExpressionEvaluator <int>(new IntCalculator(assignmentNode.Token));
assignmentNode.Expression.Accept(intEval);
expressionValue = new FloatValueNode()
{
Value = intEval.Result
};
break;
case SymbolType.Array:
var arrayEval = new ExpressionEvaluator <ArrayNode>(new ArrayCalculator(assignmentNode.Token));
assignmentNode.Expression.Accept(arrayEval);
expressionValue = arrayEval.Result;
break;
case SymbolType.Exit:
var exitEval = new ExpressionEvaluator <ExitValueNode>(new ExitValueCalculator(assignmentNode.Token));
assignmentNode.Expression.Accept(exitEval);
expressionValue = exitEval.Result;
break;
case SymbolType.Identifier:
var idEval = new ExpressionEvaluator <ValueNode>(new NoOpCalculator <ValueNode>(assignmentNode.Token));
assignmentNode.Expression.Accept(idEval);
expressionValue = idEval.Result;
break;
case SymbolType.MemberAccess:
expressionValue = (ValueNode)assignmentNode.Expression;
break;
default:
throw new ArgumentOutOfRangeException();
}
assignmentNode.Expression = expressionValue;
VariableSymbolTableEntry entry = new VariableSymbolTableEntry(expressionValue, expressionType);
CurrentScope.AddOrUpdateSymbol(assignmentNode.Identifier, entry);
}
protected virtual void VisitFloatValue(FloatValueNode node)
{
}
public void Visit(FloatValueNode floatValueNode)
{
}
public void Visit(FloatValueNode floatValueNode)
{
Result = Calculator.GetValue(floatValueNode.Value);
}
internal abstract void Visit(FloatValueNode node);
public void Visit(FloatValueNode floatValueNode)
{
sb.Append(floatValueNode.Value);
}
/// <inheritdoc/>
public override string Print(FloatValueNode node)
{
return($"{node.Value}");
}
public override void Visit(FloatValueNode node)
{
Console.Write(node.FloatValue.ToString().Replace(",", "."));
}
/// <summary> /// Executes operation on a <see cref="FloatValueNode"/>. /// </summary> /// <param name="node">The <see cref="FloatValueNode"/> to execute operation on.</param> /// <returns>The result of the operation on a <see cref="FloatValueNode"/>.</returns> public virtual ExpNode Execute(FloatValueNode node) => Execute((NumericalValueNode)node);
public override void Visit(FloatValueNode node)
{
node.Type = "float";
}
public void Visit(FloatValueNode floatValueNode)
{
typeHandler.SetType(floatValueNode.Type, floatValueNode.Token);
}
public override void Visit(FloatValueNode node)
{
CSharpString.Append(node.FloatValue.ToString().Replace(",", ".") + "f");
}
