public int CompareTo(Number other)
{
int result = Value.CompareTo(other.Value);
if (result != 0 || Operator == Operator.Create && other.Operator == Operator.Create)
{
return(result);
}
if (Operator == Operator.Create)
{
return(-1);
}
if (other.Operator == Operator.Create)
{
return(1);
}
result = Operand1.CompareTo(other.Operand1);
if (result != 0)
{
return(result);
}
return(Operand2.CompareTo(other.Operand2));
}
public override object EvalValue(Func <string, object> context)
{
object a = Operand1.EvalValue(context);
object b = Operand2.EvalValue(context);
if (a == null || b == null)
{
return(null);
}
else if (double.TryParse(a.ToString(), out double aNumber) && double.TryParse(b.ToString(), out double bNumber))
{
return(aNumber + bNumber);
}
else if (a is DateTime && double.TryParse(b.ToString(), out bNumber))
{
return(((DateTime)a).AddDays(bNumber));
}
else if (a is string || b is string)
{
return(string.Format("{0}{1}", a, b));
}
else
{
throw new Exceptions.UnexpectedTypeException(a.GetType());
}
}
public override Object Evaluate(ExpressionContext context)
{
OperandValue1 = Operand1.Evaluate(context);
OperandValue2 = Operand2.Evaluate(context);
return(OperandValue1 != OperandValue2);
}
public override List <SymbolToken> Tokenize()
{
// TODO: It's probably better to have a "prettify" tree transform
// that always runs before tokenizing an expression rather than
// manually manipulating stuff here...
var leftNegated = Operand1.Type == SymbolType.Negation;
var tokens = new List <SymbolToken>();
if (leftNegated)
{
tokens.AddRange(Operand2.Tokenize());
tokens.Add(new SymbolToken(SymbolType.Subtraction, "-"));
if (Operand1.Type.IsValue())
{
tokens.AddRange(Operand1.Tokenize());
}
else
{
tokens.Add(SymbolToken.OpenBracket);
tokens.AddRange(Operand1.Tokenize());
tokens.Add(SymbolToken.CloseBracket);
}
return(tokens);
}
// Reverses addition (commutative -- See TODO above)
tokens.AddRange(Operand2.Tokenize());
tokens.Add(new SymbolToken(Type, SymbolToken.OperatorStringOf(Type)));
tokens.AddRange(Operand1.Tokenize());
return(tokens);
}
private void Button1_Click(object sender, EventArgs e)
{
bool flag;
float Operand1;
float Operand2;
float answer;
flag = float.TryParse(txtOperand1.Text, out Operand1);
if (flag == false)
{
MessageBox.Show("Enter a whole number", "Input Error");
txtOperand1.Focus();
return;
}
flag = float.TryParse(txtOperand2.Text, out Operand2);
if (flag == false)
{
MessageBox.Show("Enter a whole number", "Input Error");
txtOperand2.Focus();
return;
}
answer = Operand1 / Operand2;
txtResult.Text = Operand1.ToString() + "devided by" + Operand2.ToString() + "equal" + answer.ToString();
txtResult.Visible = true;
}
public override string ToString()
{
string s = Opcode.ToString();
if (Size != 0)
{
s = s + "/" + Size.ToString();
}
if (Operand1 != null)
{
s = s + " " + Operand1.ToString();
}
if (Operand2 != null)
{
s = s + ", " + Operand2.ToString();
}
if (Operand3 != null)
{
s = s + ", " + Operand3.ToString();
}
if (Operand4 != null)
{
s = s + ", " + Operand4.ToString();
}
return(s);
}
/// <summary>
/// Returns the string representation of the expression.
/// </summary>
/// <returns>Returns the string representation of the expression.</returns>
public override string ToString()
{
var sb = new StringBuilder();
if (Operand1.IsAtomOrPrimitive())
{
sb.Append(Operand1);
}
else
{
sb.Append("(").Append(Operand1.ToString()).Append(")");
}
sb.Append(" ").Append(Operator1).Append(" ");
if (Operand2.IsAtomOrPrimitive())
{
sb.Append(Operand2);
}
else
{
sb.Append("(").Append(Operand2.ToString()).Append(")");
}
sb.Append(" ").Append(Operator2).Append(" ");
if (Operand3.IsAtomOrPrimitive())
{
sb.Append(Operand3);
}
else
{
sb.Append("(").Append(Operand3.ToString()).Append(")");
}
return(sb.ToString());
}
public override object EvalValue(Func <string, object> context)
{
object a = Operand1.EvalValue(context);
object b = Operand2.EvalValue(context);
if (a == null || b == null)
{
return(null);
}
if (a is double && b is double)
{
return((double)a + (double)b);
}
else if (a is DateTime && b is double)
{
return(((DateTime)a).AddDays((double)b));
}
else if (a is string || b is string)
{
return(string.Format("{0}{1}", a, b));
}
else
{
throw new Exceptions.UnexpectedTypeException(a.GetType());
}
}
private void Calc()
{
bool hasError = false;
if (Operand1 == null || Operand2 == null || Operation == "")
{
// _logger.error("input data not valid");
return;
}
switch (Operation)
{
case "+":
_result = Operand1 + Operand2;
break;
case "-":
_result = Operand1 - Operand2;
break;
case "*":
_result = Operand1 * Operand2;
break;
case "^2":
_result = Operand1 * Operand1;
break;
case "/":
if (0 == Operand2)
{
_logger.Error("divide by 0");
hasError = true;
break;
}
_result = Operand1 / Operand2;
break;
default:
_logger.Error($"invalid operation \"{Operation}\"");
hasError = true;
break;
}
if (hasError)
{
return;
}
_logger.Log(
Operand1.ToString(),
Operation != "^2" ? Operand2.ToString() : "",
Operation,
_result ?? default(double)
);
Operand1 = _result;
Operation = "";
Operand2 = null;
}
public override void Prepare()
{
base.Prepare();
if (!(Operand1.GetResultType() == SimpleTypes.String && Operand2.GetResultType() == SimpleTypes.Integer))
{
TypesException();
}
SetResultType(SimpleTypes.String);
GetStrResultOut = CalcAsStr;
}
public override bool IsEquivalentTo(AstNode otherNode)
{
// a binary operator is equivalent to another binary operator if the operator is the same and
// both operands are also equivalent
var otherBinary = otherNode as BinaryOperator;
return(otherBinary != null &&
OperatorToken == otherBinary.OperatorToken &&
Operand1.IsEquivalentTo(otherBinary.Operand1) &&
Operand2.IsEquivalentTo(otherBinary.Operand2));
}
public override Object Evaluate(ExpressionContext context)
{
if (Operand1 is VariableExpression variableExpression)
{
OperandValue2 = Operand2.Evaluate(context);
context.Bind(variableExpression.VariableName, OperandValue2);
}
return(null);
}
public override void Prepare()
{
base.Prepare();
if (!(Operand1.GetResultType() == SimpleTypes.String && Operand2.GetResultType() == SimpleTypes.String))
{
TypesException();
}
//if (!Operand2.OnlyOnline()) OperandOnlyConstException(2);
SetResultType(SimpleTypes.Boolean);
GetBoolResultOut = CalcAsBool;
}
public override void Prepare()
{
base.Prepare();
SimpleTypes t1 = Operand1.GetResultType();
SimpleTypes t2 = Operand2.GetResultType();
//public enum ColumnSimpleTypes { Integer = 1, Float = 2, String = 3, Geometry = 4, Date = 5, DateTime = 6, Time = 7, Boolean = 8 }
if (t1 == SimpleTypes.String && t2 == SimpleTypes.String)
{
GetStrResultOut = CalcAsStr;
SetResultType(SimpleTypes.String);
return;
}
if (t1 == SimpleTypes.Integer && t2 == SimpleTypes.Integer)
{
GetIntResultOut = CalcAsInt;
SetResultType(SimpleTypes.Integer);
return;
}
if ((t1 == SimpleTypes.Integer || t1 == SimpleTypes.Float) &&
(t2 == SimpleTypes.Integer || t2 == SimpleTypes.Float))
{
GetFloatResultOut = CalcAsFloat;
SetResultType(SimpleTypes.Float);
return;
}
if ((t1 == SimpleTypes.DateTime || t1 == SimpleTypes.Date) && t2 == SimpleTypes.Time)
{
GetDateTimeResultOut = CalcAsDateTimeAndTime1;
SetResultType(SimpleTypes.DateTime);
return;
}
if ((t2 == SimpleTypes.DateTime || t2 == SimpleTypes.Date) && t1 == SimpleTypes.Time)
{
GetDateTimeResultOut = CalcAsDateTimeAndTime2;
SetResultType(SimpleTypes.DateTime);
return;
}
if (t2 == SimpleTypes.Time && t1 == SimpleTypes.Time)
{
GetTimeResultOut = CalcAsTimeAndTime;
SetResultType(SimpleTypes.Time);
return;
}
/*if (t2 == ColumnSimpleTypes.Geometry && t1 == ColumnSimpleTypes.Geometry)
* {
* GetGeomResultOut = CalcAsGeom;
* SetResultType(ColumnSimpleTypes.Geometry);
* return;
* }*/
TypesException();
}
public override string ToSql(ExpressionSqlBuilder builder)
{
if (builder.DbType == DriverType.SqlServer)
{
return(string.Format("(CHARINDEX(upper({0}),upper({1}))>0)", Operand2.ToSql(builder), Operand1.ToSql(builder)));
}
if (builder.DbType == DriverType.PostgreSQL)
{
return(string.Format("(position(upper({0}) in upper({1}))>0)", Operand2.ToSql(builder), Operand1.ToSql(builder)));
}
return(ToSqlException());
}
public static BitArray BuildCommand(OperationCode opCode, Operand1 op1, Operand2 op2, Destination dest, bool jmpIfZero, int constant)
{
var array = new BitArray(16);
if (constant < 0)
{
array[4] = true;
constant = -constant - 1;
for (int i = 0; i < 4; i++)
{
array[i] = constant % 2 == 0;
constant /= 2;
}
}
else
{
for (int i = 0; i < 4; i++)
{
array[i] = constant % 2 == 1;
constant /= 2;
}
}
array[5] = jmpIfZero;
var operation = (int)opCode;
for (int i = 6; i < 10; i++)
{
array[i] = operation % 2 == 1;
operation /= 2;
}
var operand2 = (int)op2;
for (int i = 10; i < 12; i++)
{
array[i] = operand2 % 2 == 1;
operand2 /= 2;
}
array[12] = op1 == Operand1.Constant;
var destination = (int)dest;
for (int i = 13; i < 15; i++)
{
array[i] = destination % 2 == 1;
destination /= 2;
}
return(array);
}
public override string ToSql(ExpressionSqlBuilder builder)
{
if (builder.DbType == DriverType.SqlServer)
{
return("DATEADD(day," + Operand2.ToSql(builder) + "," + Operand1.ToSql(builder) + ")");
}
if (builder.DbType == DriverType.PostgreSQL)
{
return("(" + Operand1.ToSql(builder) + "+" + Operand2.ToSql(builder) + " * interval '1 day')");
}
return(ToSqlException());
}
public override string ToSql(ExpressionSqlBuilder builder)
{
//return ((IDriverDatabaseGeomixer)builder.Driver).BuildExpContains(Operand2.ToSQL(builder), Operand1.ToSQL(builder));
if (builder.DbType == DriverType.SqlServer)
{
return(string.Format("(CHARINDEX({0},{1})>0)", Operand2.ToSql(builder), Operand1.ToSql(builder)));
}
if (builder.DbType == DriverType.PostgreSQL)
{
return(string.Format("(position({0} in {1})>0)", Operand2.ToSql(builder), Operand1.ToSql(builder)));
}
return(ToSqlException());
}
public override string ToSql(ExpressionSqlBuilder builder)
{
//return ((IDriverDatabaseGeomixer)builder.Driver).BuildExpStartWith(Operand2.ToSQL(builder), Operand1.ToSQL(builder));
if (builder.DbType == DriverType.SqlServer)
{
return(string.Format("LEFT(upper({1}), len({0})) = upper({0})", Operand2.ToSql(builder), Operand1.ToSql(builder)));
}
if (builder.DbType == DriverType.PostgreSQL)
{
return(string.Format("LEFT(upper({1}), length({0})) = upper({0})", Operand2.ToSql(builder), Operand1.ToSql(builder)));
}
return(ToSqlException());
}
public override void Prepare()
{
base.Prepare();
if (Operand1.GetResultType() != SimpleTypes.Boolean)
{
this.TypesException();
}
if (Operand2.GetResultType() != SimpleTypes.Boolean)
{
this.TypesException();
}
GetBoolResultOut = AsBool;
SetResultType(SimpleTypes.Boolean);
}
public override void Prepare()
{
base.Prepare();
if (!(Operand1.GetResultType() == SimpleTypes.String))
{
TypesException(); //substring
}
if (!(Operand2.GetResultType() == SimpleTypes.String))
{
TypesException(); //string
}
SetResultType(SimpleTypes.Integer);
GetIntResultOut = CalcRes;
}
public override object EvalValue(Func <string, object> context)
{
object value = Operand1.EvalValue(context);
if (value.ConvertToBoolean())
{
return(true);
}
else
{
value = Operand2.EvalValue(context);
return(value.ConvertToBoolean());
}
}
/// <summary>
/// Retourne la valeur de l'opération.
/// </summary>
/// <returns></returns>
public object GetValue(Context context)
{
// Si l'opérateur vaut null, par convention, la seconde opérande vaut null.
// La valeur à retourner est celle de la première opérande.
if (Operator == null)
{
return(Operand1.GetValue(context));
}
var operand1 = Operand1.GetValue(context);
var operand2 = Operand2.GetValue(context);
object value = Operator.Operation(operand1, operand2);
return(value);
}
public override string ToSql(ExpressionSqlBuilder builder)
{
if (builder.DbType == DriverType.SqlServer)
{
string op = "+";
SimpleTypes t1 = Operand1.GetResultType();
SimpleTypes t2 = Operand2.GetResultType();
if (t2 == SimpleTypes.Time && t1 == SimpleTypes.Time)
{
return("CONVERT(time, CONVERT(datetime, " + Operand1.ToSql(builder) + ")" + op + "CONVERT(datetime, " + Operand2.ToSql(builder) + "))");
}
if (t1 == SimpleTypes.Date && t2 == SimpleTypes.Time)
{
return("(CONVERT(datetime, " + Operand1.ToSql(builder) + ")" + op + Operand2.ToSql(builder) + ")");
}
if (t2 == SimpleTypes.Date && t1 == SimpleTypes.Time)
{
return("(CONVERT(datetime, " + Operand2.ToSql(builder) + ")" + op + Operand1.ToSql(builder) + ")");
}
if (t1 == SimpleTypes.Geometry && t2 == SimpleTypes.Geometry)
{
if (op == "+")
{
return("(" + Operand2.ToSql(builder) + ".STUnion(" + Operand1.ToSql(builder) + "))");
}
if (op == "-")
{
return("(" + Operand2.ToSql(builder) + ".STDifference(" + Operand1.ToSql(builder) + "))");
}
}
return("(" + Operand1.ToSql(builder) + op + Operand2.ToSql(builder) + ")");
}
if (builder.DbType == DriverType.PostgreSQL)
{
string op = "+";
SimpleTypes t1 = Operand1.GetResultType();
SimpleTypes t2 = Operand2.GetResultType();
if (t1 == SimpleTypes.String || t2 == SimpleTypes.String)
{
op = "||";
}
if (t2 == SimpleTypes.Time && t1 == SimpleTypes.Time)
{
return("(" + Operand1.ToSql(builder) + op + "CAST(" + Operand2.ToSql(builder) + " as interval))");
}
return("(" + Operand1.ToSql(builder) + op + Operand2.ToSql(builder) + ")");
}
return(ToSqlException());
}
public override string ToSql(ExpressionSqlBuilder builder)
{
if (builder.DbType == DriverType.SqlServer)
{
return("CHARINDEX(" + Operand1.ToSql(builder) + ", " + Operand2.ToSql(builder) + ")");
}
else if (builder.DbType == DriverType.PostgreSQL)
{
return("position(" + Operand1.ToSql(builder) + " in " + Operand2.ToSql(builder) + ")");
}
else
{
return(ToSqlException());
}
}
private void ButtonOperator_Click(object sender, RoutedEventArgs e)
{
Button OperationButton = sender as Button;
string Operation = OperationButton.Name;
if (double.TryParse(Operand2.Text, out double Operand2Num) && double.TryParse(Operand1.Text, out double Operand1Num))
{
switch (Operation)
{
case "ButtonAdd":
Answer.Text = Convert.ToString(Operand1Num + Operand2Num);
break;
case "ButtonSubtract":
Answer.Text = Convert.ToString(Operand1Num - Operand2Num);
break;
case "ButtonDivide":
if (Operand2Num == 0)
{
DivideByZeroError DivByZeroErrorWin = new DivideByZeroError();
DivByZeroErrorWin.Show();
Operand2.Focus();
}
else
{
Answer.Text = Convert.ToString(Operand1Num / Operand2Num);
}
break;
case "ButtonMultiply":
Answer.Text = Convert.ToString(Operand1Num * Operand2Num);
break;
default:
Answer.Text = "???";
break;
}
}
else
{
ValidationError1 ValidationErrorWin = new ValidationError1();
ValidationErrorWin.Show();
}
}
private EquationParts GetEquationPartToBeCorrected()
{
if (Operand1.Contains('?'))
{
return(EquationParts.Operand1);
}
if (Operand2.Contains('?'))
{
return(EquationParts.Operand2);
}
if (Result.Contains('?'))
{
return(EquationParts.Result);
}
else
{
return(EquationParts.Invalid);
}
}
public override object EvalValue(Func <string, object> context)
{
object a = Operand1.EvalValue(context);
object b = Operand2.EvalValue(context);
if (a == null || b == null)
{
return(null);
}
if (a is double && b is double)
{
return((double)a % (double)b);
}
else
{
throw new Exceptions.UnexpectedTypeException(a.GetType());
}
}
public override object EvalValue(Func <string, object> context)
{
object a = Operand1.EvalValue(context);
object b = Operand2.EvalValue(context);
if (a == null || b == null)
{
return(null);
}
if (a is decimal && b is decimal)
{
return(Convert.ToDecimal(Math.Pow(Convert.ToDouble(a), Convert.ToDouble(b))));
}
else
{
throw new Exceptions.UnexpectedTypeException(a.GetType());
}
}
public override object EvalValue(Func <string, object> context)
{
object a = Operand1.EvalValue(context);
object b = Operand2.EvalValue(context);
if (a == null || b == null)
{
return(null);
}
if (a is double && b is double)
{
return((double)a * (double)b);
}
else
{
throw new FormatException();
}
}
