internal override object Eval()
{
var left = LeftOperand.Eval();
var right = RightOperand.Eval();
return(Microsoft.VisualBasic.CompilerServices.LikeOperator.LikeString(left as string ?? left.ToString(), right as string ?? right.ToString(), Microsoft.VisualBasic.CompareMethod.Text));
}
internal override object Eval()
{
var left = LeftOperand.Eval();
var right = RightOperand.Eval();
return(!left.Equals(right));
}
internal override object Eval()
{
var left = LeftOperand.Eval();
var right = RightOperand.Eval();
return(Regex.Match(left as string ?? left.ToString(), right as string ?? right.ToString()));
}
internal override object Eval()
{
var left = LeftOperand.Eval();
var right = RightOperand.Eval();
if (left.GetType() == right.GetType())
{
return(!left.Equals(right));
}
return(!(left as string ?? left.ToString()).Equals(right as string ?? right.ToString()));
}
internal override object Eval()
{
var left = LeftOperand.Eval();
var right = RightOperand.Eval();
if (left.GetType() == right.GetType() && left is IComparable lCom && right is IComparable rCom)
{
return(lCom.CompareTo(rCom) >= 0);
}
return((left as string ?? left.ToString()).CompareTo((right as string ?? right.ToString())) >= 0);
}
internal override object Eval()
{
var left = LeftOperand.Eval();
var right = RightOperand.Eval();
if (left is double lDbl && right is double rDbl)
{
return(Math.Pow(lDbl, rDbl));
}
//if (left is bool lBool && right is bool rBool) return Math.Pow((lBool ? 1 : 0), (rBool ? 1 : 0));
//if (left is bool lBool2 && right is double rDbl2) return Math.Pow((lBool2 ? 1 : 0), rDbl2);
//if (left is double lDbl2 && right is bool rBool2) return Math.Pow(lDbl2, (rBool2 ? 1 : 0));
throw new InvalidOperationException($"Power can not be performed on the operands [{left}] and [{right}]");
}
internal override object Eval()
{
var left = LeftOperand.Eval();
var right = RightOperand.Eval();
if (left is double lDbl && right is double rDbl)
{
return(lDbl * rDbl);
}
if (left is bool lBool && right is bool rBool)
{
return((lBool ? 1 : 0) * (rBool ? 1 : 0));
}
if (left is bool lBool2 && right is double rDbl2)
{
return((lBool2 ? 1 : 0) * rDbl2);
}
if (left is double lDbl2 && right is bool rBool2)
{
return(lDbl2 * (rBool2 ? 1 : 0));
}
throw new InvalidOperationException($"Multiplication can not be performed on the operands [{left}] and [{right}]");
}
internal override object Eval()
{
var left = LeftOperand.Eval();
var right = RightOperand.Eval();
if (left is double lDbl && right is double rDbl)
{
return(lDbl - rDbl);
}
if (left is bool lBool && right is bool rBool)
{
return((lBool ? 1 : 0) - (rBool ? 1 : 0)); // Maybe throw an exception instead?
}
if (left is bool lBool2 && right is double rDbl2)
{
return((lBool2 ? 1 : 0) - rDbl2);
}
if (left is double lDbl2 && right is bool rBool2)
{
return(lDbl2 - (rBool2 ? 1 : 0));
}
return(left.ToString().Replace(right.ToString(), "")); //Interesting concept... I wonder if other languages do this?
}
internal override object Eval()
{
var left = LeftOperand.Eval();
var right = RightOperand.Eval();
if (left is double lDbl && right is double rDbl)
{
return(lDbl + rDbl);
}
if (left is bool lBool && right is bool rBool)
{
return((lBool ? 1 : 0) + (rBool ? 1 : 0));
}
if (left is bool lBool2 && right is double rDbl2)
{
return((lBool2 ? 1 : 0) + rDbl2);
}
if (left is double lDbl2 && right is bool rBool2)
{
return(lDbl2 + (rBool2 ? 1 : 0));
}
return(left.ToString() + right.ToString());
}
