public object VisitExpression2(Expression2 expression2, object o)
{
if (expression2.Operator2 == null)
{
return(expression2.Expression3.Visit(this, o));
}
var lv2IntyOpr = new List <string>()
{
"+", "-"
};
var t1 = (VariableType.ValueTypeEnum)expression2.Expression1.Visit(this, o);
var t2 = (VariableType.ValueTypeEnum)expression2.Expression3.Visit(this, o);
if (t1 == VariableType.ValueTypeEnum.NOTHING || t2 == VariableType.ValueTypeEnum.NOTHING)
{
throw new Exception("<Nothing> not a valid operand for " + expression2.Operator2.Spelling + " operator");
}
if (t1 != t2)
{
throw new Exception("The operands for a Operator2 operator must be of same type");
}
if (lv2IntyOpr.Contains(expression2.Operator2.Spelling))
{
if (t1 == VariableType.ValueTypeEnum.INTY)
{
return(VariableType.ValueTypeEnum.INTY);
}
else
{
throw new Exception("Operator " + expression2.Operator2.Spelling + " expexted inty operands");
}
}
else if ("or".Equals(expression2.Operator2.Spelling))
{
if (t1 == VariableType.ValueTypeEnum.BOOLY)
{
return(VariableType.ValueTypeEnum.BOOLY);
}
else
{
throw new Exception("Operator " + expression2.Operator2.Spelling + " expexted booly operands");
}
}
throw new Exception("Something bad happened, code: 98465+4865");
}
private Expression1 ParseExpression1()
{
Expression2 expression2 = ParseExpression2();
Operator1 operator1 = null;
Expression1 expression1 = null;
if (Token.TokenType.OPERATOR_1 == _currentToken.TheTokenType)
{
operator1 = new Operator1(Accept(Token.TokenType.OPERATOR_1));
expression1 = ParseExpression1();
}
return(new Expression1(expression2, operator1, expression1));
}
public static void Print(Expression2 e, StringBuilder sb)
{
if (e is DoubleExpression2 de)
{
sb.Append(de.Value);
}
else if (e is AdditionExpression2 ae)
{
sb.Append("(");
Print(ae.Left, sb);
Print(ae.Right, sb);
sb.Append(")");
}
}
public Value Eval()
{
var value1 = Expression1.Eval();
var value2 = Expression2.Eval();
return(value1 switch
{
IntegerValue => Operation switch
{
Operations.Plus => new IntegerValue(value1.AsInteger() + value2.AsInteger()),
Operations.Minus => new IntegerValue(value1.AsInteger() - value2.AsInteger()),
Operations.Multiply => new IntegerValue(value1.AsInteger() * value2.AsInteger()),
Operations.Divide => new IntegerValue(value1.AsInteger() / value2.AsInteger()),
_ => throw new ArgumentOutOfRangeException()
},
override public void Pretty(PrettyBuilder builder, int outerPrecedence, bool opposite)
{
var precedence = Precedences[Operator];
var associativity = Associativities[Operator];
if (outerPrecedence > precedence || opposite && outerPrecedence == precedence)
{
builder.Append("(");
}
Expression1.Pretty(builder, precedence, associativity == Associativity.Right);
builder.Append(Strings[Operator]);
Expression2.Pretty(builder, precedence, associativity == Associativity.Left);
if (outerPrecedence > precedence || opposite && outerPrecedence == precedence)
{
builder.Append(")");
}
}
// public Expression Expression1;
// public Expression Expression2;
override public void Pretty(PrettyBuilder builder, int outerPrecedence, bool opposite)
{
if (outerPrecedence > 0)
{
builder.Append("(");
builder.Indent();
builder.NewLine();
}
Expression1.Pretty(builder, 0, false);
builder.Append(", ");
builder.NewLine();
Expression2.Pretty(builder, 0, false);
if (outerPrecedence > 0)
{
builder.Unindent();
builder.NewLine();
builder.Append(")");
builder.NewLine();
}
}
public override Type Typecheck(TypecheckingState state)
{
var type1 = Expression1.Typecheck(state);
var type2 = Expression2.Typecheck(state);
OperandType = type1;
switch (Operator)
{
case BinaryOperator.Add:
if (type1 != Type.NumType && type2 != Type.NumType)
{
TypeError("+ expects number operands");
}
return(Type.NumType);
case BinaryOperator.Sub:
if (type1 != Type.NumType && type2 != Type.NumType)
{
TypeError("- expects number operands");
}
return(Type.NumType);
case BinaryOperator.Eq:
if (type1 != type2)
{
TypeError("== expects operands of the same type");
}
return(Type.BoolType);
case BinaryOperator.Lt:
if (type1 != Type.NumType && type2 != Type.NumType)
{
TypeError("- expects number operands");
}
return(Type.BoolType);
}
throw new ImpossibleException();
}
/// <summary>
/// 验证结果
/// </summary>
/// <param name="value">待验证值</param>
/// <returns></returns>
public override ValidateResult Validate(object value)
{
ValidateResult r = new ValidateResult();
r.Valid = false;
r.ErrorTextKey = this.ErrorText;
int v = 0;
if (Expression == null || value == null || !int.TryParse(value.ToString(), out v))
{
return(r);
}
if (Expression2 != null && Validator.IsInteger(Expression.ToString()) && Validator.IsInteger(Expression2.ToString()))
{
r.Valid = v >= int.Parse(Expression.ToString()) && v <= int.Parse(Expression2.ToString());
}
if (Expression2 == null && Validator.IsDecimal(Expression.ToString()))
{
r.Valid = v == int.Parse(Expression.ToString());
}
return(r);
}
static void Test()
{
string[] stExp = new string[9]
{
"log(4-2, 8)",
" - 2.0+3-1.6+ 8.3 ",
" 2.0*3.5-4.2/3",
"(2.0-3)*(5/(3+3)-4.2)",
"4^3^0.5-2^(3^2-2*3)",
"log(4-2, 8)+lg(123)",
"log(log(10,100), 8) + 1.2",
"sin((ln(2)-2)*log(3, 2*3^2))",
"-min(sin(ln(2.5^1.5+2*0.3)-1.3), cos(0.8^log(2,5)), 0.7^(5/2)) + max(1.8, 2, -2, 2.3, log(5, 118))"
};
double[] expectedResult = new double[9]
{
Math.Log(8, 4 - 2),
-2.0 + 3 - 1.6 + 8.3,
2.0 * 3.5 - 4.2 / 3,
(2.0 - 3) * (5.0 / (3 + 3) - 4.2),
Math.Pow(Math.Pow(4, 3), 0.5) - Math.Pow(2, (Math.Pow(3, 2) - 2 * 3)),
Math.Log(8, 4 - 2) + Math.Log10(123),
Math.Log(8, Math.Log(100, 10)) + 1.2,
Math.Sin((Math.Log(2.0) - 2) * Math.Log(2.0 * Math.Pow(3.0, 2), 3)),
-Math.Min(Math.Min(Math.Sin(Math.Log(Math.Pow(2.5, 1.5) + 2.0 * 0.3) - 1.3), Math.Cos(Math.Pow(0.8, Math.Log(5, 2)))), Math.Pow(0.7, 5.0 / 2)) + Math.Max(2.3, Math.Log(118, 5))
};
Expression2 exp;
for (int i = 0; i < stExp.Length; i++)
{
exp = new Expression2(stExp[i]);
double actual = exp.Result();
Console.WriteLine("{0}\n{1}", stExp[i], exp);
System.Console.WriteLine("{0}! Expected: {1}, Actual: {2}\n", Math.Abs(actual - expectedResult[i]) < 1e-10 ? "Correct" : "Wrong", expectedResult[i], actual);
}
}
// public Expression Expression1;
// public Expression Expression2;
public override void Compile(GeneratorState state, Trac42Program program)
{
Expression1.Compile(state, program);
program.Emit(new Instruction(Instruction.OPCODE.POP, 1));
Expression2.Compile(state, program);
}
internal override double Evaluate()
{
return(Math.Pow(Expression1.Evaluate(), Expression2.Evaluate()));
}
/// <summary>
/// Возвращает текст выражения
/// </summary>
public override string ToText( )
{
return(string.Format("{0}{1}{2}{3}{4}", Expression1.ToText( ), Compiler.GetOperator(Name).Signatures[0],
Expression2.ToText( ), Compiler.GetOperator(Name).Signatures[1], Expression3.ToText( )));
}
internal override double Evaluate()
{
return(Expression1.Evaluate() / Expression2.Evaluate());
}
public static void Print(Expression2 e, StringBuilder sb)
{
actions[e.GetType()](e, sb);
}
public Expression1(Expression2 expression2, Operator1 operator1, Expression1 expression1)
{
Expression2 = expression2;
Operator1 = operator1;
Expression1_ = expression1;
}
// public BinaryOperator Operator;
// public Expression Expression1;
// public Expression Expression2;
public override Expression Lift(LiftEnvironment env)
{
Expression1 = Expression1.Lift(env);
Expression2 = Expression2.Lift(env);
return(this);
}
// public Expression Expression1;
// public Expression Expression2;
public override void FreeVariables(HashSet <string> boundVariables, HashSet <string> freeVariables)
{
Expression1.FreeVariables(boundVariables, freeVariables);
Expression2.FreeVariables(boundVariables, freeVariables);
}
public Expression2 Left, Right; // need to be public
public AdditionExpression2(Expression2 left, Expression2 right)
{
Left = left ?? throw new ArgumentNullException(paramName: nameof(left));
Right = right ?? throw new ArgumentNullException(paramName: nameof(right));
}
// public Expression Expression1;
// public Expression Expression2;
public override Type Typecheck(TypecheckingState state)
{
Expression1.Typecheck(state);
return(Expression2.Typecheck(state));
}
public override decimal Solve()
{
return(Expression1.Solve() / Expression2.Solve());
}
///--------------------------------------------------------------------------------
/// <summary>Evaluate expression associated with this node.</summary>
///
/// <param name="solutionContext">The associated solution.</param>
/// <param name="templateContext">The associated template.</param>
/// <param name="modelContext">The associated model context.</param>
/// <param name="interpreterType">The type of interpretation to perform.</param>
///--------------------------------------------------------------------------------
public string GetExpressionValue(Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext, InterpreterTypeCode interpreterType)
{
string expression1Value = String.Empty;
if (Expression1 != null)
{
expression1Value = Expression1.GetExpressionValue(solutionContext, templateContext, modelContext, interpreterType);
}
string expression2Value = String.Empty;
if (Expression2 != null)
{
expression2Value = Expression2.GetExpressionValue(solutionContext, templateContext, modelContext, interpreterType);
}
if (String.IsNullOrEmpty(expression1Value))
{
expression1Value = "null";
}
if (String.IsNullOrEmpty(expression2Value))
{
expression2Value = "null";
}
long expression1Long;
long expression2Long;
double expression1Double;
double expression2Double;
if (Literal != null)
{
return(Literal.RawValue);
}
if (ModelProperty != null)
{
return(ModelProperty.GetPropertyStringValue(solutionContext, templateContext, modelContext, modelContext, interpreterType));
}
if (ModelContext != null)
{
bool isValidContext;
IDomainEnterpriseObject nodeContext = ModelContext.GetModelContext(solutionContext, templateContext, modelContext, out isValidContext);
if (nodeContext == null)
{
return("null");
}
else
{
if (nodeContext.ID == Guid.Empty || nodeContext.ID == null)
{
return("null");
}
return(nodeContext.ID.ToString());
}
}
else if (CurrentItem != null)
{
IDomainEnterpriseObject nodeContext = CurrentItem.GetModelContext(solutionContext, templateContext, modelContext);
if (nodeContext == null)
{
return("null");
}
else
{
return(nodeContext.ID.ToString());
}
}
else if (SpecCurrentItem != null)
{
IDomainEnterpriseObject nodeContext = SpecCurrentItem.GetModelContext(solutionContext, templateContext, modelContext);
if (nodeContext == null)
{
return("null");
}
else
{
return(nodeContext.ID.ToString());
}
}
else if (Expression1 != null && Expression2 != null)
{
if (BinaryOperator != null)
{
switch (BinaryOperator.Operator)
{
case "||":
if (Expression1.EvaluateExpression(solutionContext, templateContext, modelContext, interpreterType) || Expression2.EvaluateExpression(solutionContext, templateContext, modelContext, interpreterType))
{
return("true");
}
return("false");
case "&&":
if (Expression1.EvaluateExpression(solutionContext, templateContext, modelContext, interpreterType) && Expression2.EvaluateExpression(solutionContext, templateContext, modelContext, interpreterType))
{
return("true");
}
return("false");
case "==":
if (expression1Value == expression2Value)
{
return("true");
}
return("false");
case "!=":
if (expression1Value != expression2Value)
{
return("true");
}
return("false");
case "<":
if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true)
{
if (expression1Long < expression2Long)
{
return("true");
}
}
else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true)
{
if (expression1Double < expression2Double)
{
return("true");
}
}
else
{
if (expression1Value.Length < expression2Value.Length)
{
return("true");
}
}
return("false");
case ">":
if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true)
{
if (expression1Long > expression2Long)
{
return("true");
}
}
else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true)
{
if (expression1Double > expression2Double)
{
return("true");
}
}
else
{
if (expression1Value.Length > expression2Value.Length)
{
return("true");
}
}
return("false");
case "<=":
if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true)
{
if (expression1Long <= expression2Long)
{
return("true");
}
}
else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true)
{
if (expression1Double <= expression2Double)
{
return("true");
}
}
else
{
if (expression1Value.Length <= expression2Value.Length)
{
return("true");
}
}
return("false");
case ">=":
if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true)
{
if (expression1Long >= expression2Long)
{
return("true");
}
}
else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true)
{
if (expression1Double >= expression2Double)
{
return("true");
}
}
else
{
if (expression1Value.Length >= expression2Value.Length)
{
return("true");
}
}
return("false");
default:
return("false");
}
}
else if (MathOperator != null)
{
switch (MathOperator.Operator)
{
case "+":
if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true)
{
return((expression1Long + expression2Long).ToString());
}
else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true)
{
return((expression1Double + expression2Double).ToString());
}
else
{
return(expression1Value + expression2Value);
}
case "-":
if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true)
{
return((expression1Long - expression2Long).ToString());
}
else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true)
{
return((expression1Double - expression2Double).ToString());
}
else
{
return(expression1Value.Replace(expression2Value, ""));
}
case "*":
if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true)
{
return((expression1Long * expression2Long).ToString());
}
else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true)
{
return((expression1Double * expression2Double).ToString());
}
break;
case "/":
if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true && expression2Long != 0)
{
return((expression1Long / expression2Long).ToString());
}
else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true && expression2Double != 0.00)
{
return((expression1Double / expression2Double).ToString());
}
break;
default:
break;
}
return("null");
}
}
else if (Expression1 != null)
{
return(Expression1.GetExpressionValue(solutionContext, templateContext, modelContext, interpreterType));
}
return("null");
}
// public BinaryOperator Operator;
// public Expression Expression1;
// public Expression Expression2;
override public void Prepass(PrepassState state)
{
Expression1.Prepass(state);
Expression2.Prepass(state);
}
