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"); }