public IParseTreeValue CreateDeclaredType(string expression, string declaredTypeName) { if (expression is null || declaredTypeName is null) { throw new ArgumentNullException(); } if (ParseTreeValue.TryGetNonPrintingControlCharCompareToken(expression, out string comparableToken)) { var charConversion = new TypeTokenPair(Tokens.String, comparableToken); return(ParseTreeValue.CreateValueType(charConversion)); } var goalTypeTokenPair = new TypeTokenPair(declaredTypeName, null); var typeToken = TypeTokenPair.ConformToType(declaredTypeName, expression); if (typeToken.HasValue) { if (LetCoerce.ExceedsValueTypeRange(typeToken.ValueType, typeToken.Token)) { return(ParseTreeValue.CreateOverflowExpression(expression, declaredTypeName)); } return(ParseTreeValue.CreateValueType(typeToken)); } return(ParseTreeValue.CreateExpression(new TypeTokenPair(declaredTypeName, expression))); }
public IParseTreeValue CreateMismatchExpression(string expression, string declaredTypeName) { if (expression is null || declaredTypeName is null) { throw new ArgumentNullException(); } return(ParseTreeValue.CreateMismatchExpression(expression, declaredTypeName)); }
public IParseTreeValue CreateValueType(string expression, string declaredTypeName) { if (expression is null || declaredTypeName is null) { throw new ArgumentNullException(); } return(ParseTreeValue.CreateValueType(new TypeTokenPair(declaredTypeName, expression))); }
public static IParseTreeValue CreateExpression(TypeTokenPair typeToken) { var ptValue = new ParseTreeValue() { _typeTokenPair = typeToken, ParsesToConstantValue = false, }; return(ptValue); }
public static bool TryLetCoerce(this IParseTreeValue parseTreeValue, string destinationType, out IParseTreeValue newValue) { newValue = null; if (LetCoerce.TryCoerceToken((parseTreeValue.ValueType, parseTreeValue.Token), destinationType, out var valueText)) { newValue = ParseTreeValue.CreateValueType(new TypeTokenPair(destinationType, valueText)); return(true); } return(false); }
public static IParseTreeValue CreateMismatchExpression(string value, string declaredValueType) { var ptValue = new ParseTreeValue() { _typeTokenPair = new TypeTokenPair(declaredValueType, value), ParsesToConstantValue = false, IsMismatchExpression = true }; return(ptValue); }
public static IParseTreeValue CreateOverflowExpression(string value, string declaredValueType) { var ptValue = new ParseTreeValue() { _typeTokenPair = new TypeTokenPair(declaredValueType, value), ParsesToConstantValue = false, _exceedsValueTypeRange = true }; return(ptValue); }
public static IParseTreeValue CreateValueType(TypeTokenPair value) { if (value.ValueType.Equals(Tokens.Date) || value.ValueType.Equals(Tokens.String)) { return(new ParseTreeValue(value)); } var ptValue = new ParseTreeValue() { _typeTokenPair = value, ParsesToConstantValue = true, IsOverflowExpression = LetCoerce.ExceedsValueTypeRange(value.ValueType, value.Token), }; return(ptValue); }
public IParseTreeValue Create(string valueToken) { if (valueToken is null || valueToken.Equals(string.Empty)) { throw new ArgumentException(); } if (HasTypeHint(valueToken, out string valueType)) { var vToken = valueToken.Remove(valueToken.Length - 1); var conformedTypeTokenPair = TypeTokenPair.ConformToType(valueType, vToken); if (conformedTypeTokenPair.HasValue) { return(ParseTreeValue.CreateValueType(conformedTypeTokenPair)); } return(ParseTreeValue.CreateExpression(new TypeTokenPair(valueType, vToken))); } if (TypeTokenPair.TryParse(valueToken, out TypeTokenPair result)) { return(ParseTreeValue.CreateValueType(result)); } return(ParseTreeValue.CreateExpression(new TypeTokenPair(null, valueToken))); }