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