public void AddIfNotPresent(ParserRuleContext context, IParseTreeValue value)
{
if (!_parseTreeValues.ContainsKey(context))
{
_parseTreeValues.Add(context, value);
}
}
private IParseTreeValue EvaluateUnaryMinus(IParseTreeValue parseTreeValue)
{
var opProvider = new OperatorTypesProvider(parseTreeValue.ValueType, ArithmeticOperators.ADDITIVE_INVERSE);
if (!parseTreeValue.ParsesToConstantValue)
{
//Unable to resolve to a value, return an expression
var opTypeName = opProvider.OperatorDeclaredType;
return(_valueFactory.CreateDeclaredType($"{ArithmeticOperators.ADDITIVE_INVERSE} {parseTreeValue.Token}", opTypeName));
}
var effTypeName = opProvider.OperatorEffectiveType;
if (effTypeName.Equals(Tokens.Date))
{
var result = DateTime.FromOADate(0 - parseTreeValue.AsDouble());
var date = new DateValue(result);
return(_valueFactory.CreateDeclaredType(date.AsDate.ToString(CultureInfo.InvariantCulture), effTypeName));
}
var declaredTypeName = opProvider.OperatorDeclaredType;
if (parseTreeValue.TryLetCoerce(out decimal decValue))
{
return(_valueFactory.CreateDeclaredType((0 - decValue).ToString(CultureInfo.InvariantCulture), declaredTypeName));
}
return(_valueFactory.CreateDeclaredType((0 - parseTreeValue.AsDouble()).ToString(CultureInfo.InvariantCulture), declaredTypeName));
}
private void GetUnaryOpValues(string operands, out IParseTreeValue LHS, out string opSymbol)
{
var operandItems = operands.Split(new string[] { OPERAND_SEPARATOR }, StringSplitOptions.None);
opSymbol = operandItems[0];
LHS = CreateInspValueFrom(operandItems[1]);
}
public void AddValueRange(IParseTreeValue inputStartVal, IParseTreeValue inputEndVal)
{
var currentRanges = new List <Tuple <T, T> >();
currentRanges.AddRange(_ranges);
_ranges.Clear();
foreach (var range in currentRanges)
{
AddValueRangeImpl(range.Item1, range.Item2);
}
if (inputStartVal.ParsesToConstantValue && inputEndVal.ParsesToConstantValue)
{
if (!(_valueConverter(inputStartVal, out T startVal) && _valueConverter(inputEndVal, out T endVal)))
{
throw new ArgumentException();
}
AddValueRangeImpl(startVal, endVal);
}
else
{
AddVariableRangeImpl(inputStartVal.ValueText, inputEndVal.ValueText);
}
_descriptorIsDirty = true;
}
public IParseTreeValue Evaluate(IParseTreeValue value, string opSymbol, string requestedResultType)
{
var isMathOp = MathOpsUnary.ContainsKey(opSymbol);
var isLogicOp = LogicOpsUnary.ContainsKey(opSymbol);
Debug.Assert(isMathOp || isLogicOp);
var operands = PrepareOperands(new string[] { value.ValueText });
if (operands.Count == 1)
{
if (isMathOp)
{
var mathResult = MathOpsUnary[opSymbol](operands[0]);
return(_valueFactory.Create(mathResult.ToString(), requestedResultType));
}
//Unary Not (!) operator
if (!value.TypeName.Equals(Tokens.Boolean) && ParseTreeValue.TryConvertValue(value, out long opValue))
{
var bitwiseComplement = ~opValue;
return(_valueFactory.Create(Convert.ToBoolean(bitwiseComplement).ToString(), requestedResultType));
}
else if (value.TypeName.Equals(Tokens.Boolean))
{
var logicResult = LogicOpsUnary[opSymbol](operands[0]);
return(_valueFactory.Create(logicResult.ToString(), requestedResultType));
}
}
return(_valueFactory.Create($"{opSymbol} {value.ValueText}", requestedResultType));
}
public IParseTreeValue Evaluate(IParseTreeValue LHS, IParseTreeValue RHS, string opSymbol)
{
if (!(IsSupportedSymbol(opSymbol)))
{
throw new ArgumentException($"Unsupported operation ({opSymbol}) passed to Evaluate function");
}
if (opSymbol.Equals(LogicalOperators.NOT))
{
throw new ArgumentException($"Unary operator ({opSymbol}) passed to binary Evaluate function");
}
var opProvider = new OperatorTypesProvider((LHS.ValueType, RHS.ValueType), opSymbol);
if (opProvider.IsMismatch)
{
return(_valueFactory.CreateMismatchExpression($"{LHS.Token} {opSymbol} {RHS.Token}", Tokens.Variant));
}
if (ArithmeticOperators.Includes(opSymbol))
{
return(EvaluateArithmeticOp(opSymbol, LHS, RHS));
}
if (RelationalOperators.Includes(opSymbol))
{
return(EvaluateRelationalOp(opSymbol, LHS, RHS));
}
return(EvaluateLogicalOperator(opSymbol, LHS, RHS));
}
private static string DetermineMathResultType(IParseTreeValue LHS, IParseTreeValue RHS)
{
var lhsTypeNameIndex = ResultTypeRanking.FindIndex(el => el.Equals(LHS.TypeName));
var rhsTypeNameIndex = ResultTypeRanking.FindIndex(el => el.Equals(RHS.TypeName));
return(lhsTypeNameIndex <= rhsTypeNameIndex ? LHS.TypeName : RHS.TypeName);
}
private string Concatenate(IParseTreeValue LHS, IParseTreeValue RHS)
{
var lhs = StripDoubleQuotes(LHS.Token);
var rhs = StripDoubleQuotes(RHS.Token);
return($"{ @""""}{lhs}{rhs}{ @""""}");
}
private IParseTreeValue EvaluateLogicalOperator(string opSymbol, IParseTreeValue LHS, IParseTreeValue RHS)
{
var opProvider = new OperatorTypesProvider((LHS.ValueType, RHS.ValueType), opSymbol);
if (!(LHS.ParsesToConstantValue && RHS.ParsesToConstantValue))
{
//Unable to resolve to a value, return an expression
var opType = opProvider.OperatorDeclaredType;
opType = opType.Equals(string.Empty) ? Tokens.Variant : opType;
return(_valueFactory.CreateExpression($"{LHS.Token} {opSymbol} {RHS.Token}", opType));
}
if (!(OperatorTypesProvider.IntegralNumericTypes.Contains(opProvider.OperatorDeclaredType)))
{
return(_valueFactory.CreateExpression($"{LHS.Token} {opSymbol} {RHS.Token}", opProvider.OperatorDeclaredType));
}
if (opSymbol.Equals(LogicalOperators.AND))
{
var result = opProvider.OperatorDeclaredType.Equals(Tokens.Boolean) ?
Calculate(LHS, RHS, (bool a, bool b) => { return(a && b); })
: Calculate(LHS, RHS, (long a, long b) => { return(a & b); });
return(_valueFactory.CreateDeclaredType(result, opProvider.OperatorDeclaredType));
}
if (opSymbol.Equals(LogicalOperators.OR))
{
var result = opProvider.OperatorDeclaredType.Equals(Tokens.Boolean) ?
Calculate(LHS, RHS, (bool a, bool b) => { return(a || b); })
: Calculate(LHS, RHS, (long a, long b) => { return(a | b); });
return(_valueFactory.CreateDeclaredType(result, opProvider.OperatorDeclaredType));
}
if (opSymbol.Equals(LogicalOperators.XOR))
{
var result = opProvider.OperatorDeclaredType.Equals(Tokens.Boolean) ?
Calculate(LHS, RHS, (bool a, bool b) => { return(a ^ b); })
: Calculate(LHS, RHS, (long a, long b) => { return(a ^ b); });
return(_valueFactory.CreateDeclaredType(result, opProvider.OperatorDeclaredType));
}
if (opSymbol.Equals(LogicalOperators.EQV))
{
var result = opProvider.OperatorDeclaredType.Equals(Tokens.Boolean) ?
Calculate(LHS, RHS, (bool a, bool b) => { return(Eqv(a, b)); })
: Calculate(LHS, RHS, (long a, long b) => { return(Eqv(a, b)); });
return(_valueFactory.CreateDeclaredType(result, opProvider.OperatorDeclaredType));
}
if (opSymbol.Equals(LogicalOperators.IMP))
{
var result = opProvider.OperatorDeclaredType.Equals(Tokens.Boolean) ?
Calculate(LHS, RHS, (bool a, bool b) => { return(Imp(a, b)); })
: Calculate(LHS, RHS, (long a, long b) => { return(Imp(a, b)); });
return(_valueFactory.CreateDeclaredType(result, opProvider.OperatorDeclaredType));
}
return(_valueFactory.CreateExpression($"{LHS.Token} {opSymbol} {RHS.Token}", opProvider.OperatorDeclaredType));
}
public ExpressionFilter(string valueType, Func <string, T> parser)
{
_selectExpressionType = valueType;
_hashCode = _selectExpressionType.GetHashCode();
Parser = parser;
_trueValue = Parse((Tokens.String, Tokens.True));
_falseValue = Parse((Tokens.String, Tokens.False));
_selectExpressionValue = null;
}
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 ClauseExpressionData(IParseTreeValue lhs, IParseTreeValue rhs, string opSymbol)
{
RHS = rhs;
LHS = lhs;
OpSymbol = opSymbol;
IsMismatch = false;
IsOverflow = (LHS != null && LHS.IsOverflowExpression) || (RHS != null && RHS.IsOverflowExpression);
IsUnreachable = false;
IsInherentlyUnreachable = false;
}
public void AddExtents(IParseTreeValue min, IParseTreeValue max)
{
_hasExtents = true;
if (_valueConverter(min, out _minExtent))
{
AddIsClauseImpl(_minExtent, LogicSymbols.LT);
}
if (_valueConverter(max, out _maxExtent))
{
AddIsClauseImpl(_maxExtent, LogicSymbols.GT);
}
}
private void Visit(VBAParser.LExprContext context)
{
if (ContextHasResult(context))
{
return;
}
IParseTreeValue newResult = null;
if (TryGetLExprValue(context, out string lexprValue, out string declaredType))
{
newResult = _inspValueFactory.Create(lexprValue, declaredType);
}
private string Compare(IParseTreeValue LHS, IParseTreeValue RHS, Func <decimal, decimal, bool> DecimalCompare, Func <double, double, bool> DoubleCompare)
{
if (DecimalCompare is null && DoubleCompare is null)
{
throw new ArgumentNullException();
}
if (!(DecimalCompare is null) && LHS.TryLetCoerce(out decimal lhsValue) && RHS.TryLetCoerce(out decimal rhsValue))
{
return(DecimalCompare(lhsValue, rhsValue) ? Tokens.True : Tokens.False);
}
return(DoubleCompare(LHS.AsDouble(), RHS.AsDouble()) ? Tokens.True : Tokens.False);
}
private string Calculate(IParseTreeValue LHS, IParseTreeValue RHS, Func <decimal, decimal, decimal> DecimalCalc, Func <double, double, double> DoubleCalc)
{
if (DecimalCalc is null && DoubleCalc is null)
{
throw new ArgumentNullException();
}
if (!(DecimalCalc is null) && LHS.TryLetCoerce(out decimal lhsValue) && RHS.TryLetCoerce(out decimal rhsValue))
{
return(DecimalCalc(lhsValue, rhsValue).ToString(CultureInfo.InvariantCulture));
}
return(DoubleCalc(LHS.AsDouble(), RHS.AsDouble()).ToString(CultureInfo.InvariantCulture));
}
public IParseTreeValue Evaluate(IParseTreeValue parseTreeValue, string opSymbol)
{
if (!(opSymbol.Equals(ArithmeticOperators.ADDITIVE_INVERSE) ||
opSymbol.Equals(LogicalOperators.NOT)))
{
throw new ArgumentException($"Binary operator ({opSymbol}) passed to unary evaluation function");
}
if (opSymbol.Equals(ArithmeticOperators.ADDITIVE_INVERSE))
{
return(EvaluateUnaryMinus(parseTreeValue));
}
return(EvaluateLogicalNot(parseTreeValue));
}
private IParseTreeValue EvaluateLogicalNot(IParseTreeValue parseTreeValue)
{
var opProvider = new OperatorTypesProvider(parseTreeValue.ValueType, LogicalOperators.NOT);
if (!parseTreeValue.ParsesToConstantValue)
{
//Unable to resolve to a value, return an expression
var opType = opProvider.OperatorDeclaredType;
opType = opType.Equals(string.Empty) ? Tokens.Variant : opProvider.OperatorDeclaredType;
return(_valueFactory.CreateExpression($"{LogicalOperators.NOT} {parseTreeValue.Token}", opType));
}
var value = parseTreeValue.AsLong();
return(_valueFactory.CreateDeclaredType((~value).ToString(CultureInfo.InvariantCulture), opProvider.OperatorDeclaredType));
}
public void AddIsClause(IParseTreeValue value, string opSymbol)
{
if (value.ParsesToConstantValue)
{
if (!_valueConverter(value, out T result))
{
throw new ArgumentException();
}
AddIsClauseImpl(result, opSymbol);
}
else
{
AddRelationalOpImpl(value.ValueText);
}
_descriptorIsDirty = true;
}
public void AddSingleValue(IParseTreeValue value)
{
if (value.ParsesToConstantValue)
{
if (!_valueConverter(value, out T result))
{
throw new ArgumentException();
}
AddSingleValueImpl(result);
}
else
{
VariableSingleValues.Add(value.ValueText);
}
_descriptorIsDirty = true;
}
public static bool TryConvertValue(IParseTreeValue parseTreeValue, out bool value)
{
value = default;
var inspVal = parseTreeValue.ValueText;
if (inspVal.Equals(Tokens.True) || inspVal.Equals(Tokens.False))
{
value = inspVal.Equals(Tokens.True);
return(true);
}
if (double.TryParse(inspVal, out double dVal))
{
value = Math.Abs(dVal) >= double.Epsilon;
return(true);
}
return(false);
}
public static bool TryConvertValue(IParseTreeValue parseTreeValue, out decimal value)
{
value = default;
var inspVal = parseTreeValue.ValueText;
if (inspVal.Equals(Tokens.True) || inspVal.Equals(Tokens.False))
{
value = inspVal.Equals(Tokens.True) ? -1 : 0;
return(true);
}
if (decimal.TryParse(inspVal, out decimal rational))
{
value = rational;
return(true);
}
return(false);
}
public static bool TryConvertValue(IParseTreeValue parseTreeValue, out long value)
{
value = default;
var inspVal = parseTreeValue.ValueText;
if (inspVal.Equals(Tokens.True) || inspVal.Equals(Tokens.False))
{
value = inspVal.Equals(Tokens.True) ? -1 : 0;
return(true);
}
if (double.TryParse(inspVal, out double rational))
{
value = Convert.ToInt64(rational);
return(true);
}
return(false);
}
public void ParseTreeValue_NullInputValue()
{
IParseTreeValue test = null;
try
{
test = ValueFactory.Create(null);
Assert.Fail("Null input to UnreachableCaseInspectionValue did not generate an Argument exception");
}
catch (ArgumentException)
{
}
catch
{
Assert.Fail("Null input to UnreachableCaseInspectionValue did not generate an exception");
}
}
public void ParseTreeValue_ConvertToBoolText(string input, string expected)
{
var ptValue = ValueFactory.Create(input);
IParseTreeValue coerced = null;
if (ptValue.ParsesToConstantValue)
{
if (!ptValue.TryLetCoerce(Tokens.Boolean, out coerced))
{
Assert.Fail($"TryLetCoerce Failed: {ptValue.ValueType}:{ptValue.Token} to {Tokens.Boolean}");
}
}
else
{
coerced = ptValue;
}
Assert.IsNotNull(coerced, $"Type conversion to {Tokens.Boolean} return null interface");
Assert.AreEqual(expected, coerced.Token);
}
private void SetSelectExpressionTypeName(ParserRuleContext context, IParseTreeVisitorResults inspValues)
{
var selectStmt = (VBAParser.SelectCaseStmtContext)context;
if (TryDetectTypeHint(selectStmt.selectExpression().GetText(), out string typeName) &&
InspectableTypes.Contains(typeName))
{
SelectExpressionTypeName = typeName;
}
else if (inspValues.TryGetValue(selectStmt.selectExpression(), out IParseTreeValue result) &&
InspectableTypes.Contains(result.ValueType))
{
_selectExpressionValue = result;
SelectExpressionTypeName = result.ValueType;
}
else
{
SelectExpressionTypeName = DeriveTypeFromCaseClauses(inspValues, selectStmt);
}
}
public IParseTreeValue Evaluate(IParseTreeValue LHS, IParseTreeValue RHS, string opSymbol)
{
var isMathOp = MathOpsBinary.ContainsKey(opSymbol);
var isLogicOp = LogicOpsBinary.ContainsKey(opSymbol);
Debug.Assert(isMathOp || isLogicOp);
var opResultTypeName = isMathOp ? DetermineMathResultType(LHS, RHS) : Tokens.Boolean;
var operands = PrepareOperands(new string[] { LHS.ValueText, RHS.ValueText });
if (operands.Count == 2)
{
if (isMathOp)
{
var mathResult = MathOpsBinary[opSymbol](operands[0], operands[1]);
return(_valueFactory.Create(mathResult.ToString(), opResultTypeName));
}
var logicResult = LogicOpsBinary[opSymbol](operands[0], operands[1]);
return(_valueFactory.Create(logicResult.ToString(), opResultTypeName));
}
return(_valueFactory.Create($"{LHS.ValueText} {opSymbol} {RHS.ValueText}", opResultTypeName));
}
CreateLogicPair(IParseTreeValue value, string opSymbol, IParseTreeValueFactory factory)
{
var operands = value.Token.Split(new string[] { opSymbol }, StringSplitOptions.None);
if (operands.Count() == 2)
{
var lhs = factory.Create(operands[0].Trim());
var rhs = factory.Create(operands[1].Trim());
if (opSymbol.Equals(Tokens.Like))
{
rhs = factory.CreateDeclaredType($"\"{rhs.Token}\"", Tokens.String);
}
return(lhs, rhs);
}
if (operands.Count() == 1)
{
var lhs = factory.Create(operands[0].Trim());
return(lhs, null);
}
return(null, null);
}
public IsClauseExpression(IParseTreeValue value, string opSymbol)
: base(value, null, opSymbol)
{
_hashCode = OpSymbol.GetHashCode();
}
public LikeExpression(IParseTreeValue lhs, IParseTreeValue rhs)
: base(lhs, rhs, Tokens.Like, false)
{
_hashCode = OpSymbol.GetHashCode();
}
