private object PlusEqual(IScriptContext context)
{
object rez = context.Result;
nameExpr.Evaluate(context);
object rezName = context.Result;
HandleOperatorArgs handling = OnHandleOperator(this, context, "+=", rezName, rez);
if (handling.Cancel)
{
rez = handling.Result;
}
else
{
rez = plus.Evaluate(rezName, rez);
}
//TODO: Events!
//if (!(rezName is EventInfo))
//{
// rez = RuntimeHost.GetBinaryOperator("+").Evaluate(rezName, rez);
//}
nameExpr.Assign(rez, context);
return(rez);
}
private object MinusEqual(IScriptContext context)
{
object rez = context.Result;
nameExpr.Evaluate(context);
object rezName = context.Result;
HandleOperatorArgs handling = OnHandleOperator(this, context, "-=", rezName, rez);
if (handling.Cancel)
{
rez = handling.Result;
}
else
{
rez = minus.Evaluate(rezName, rez);
}
//if (!(rezName is EventInfo))
//{
// rez = RuntimeHost.GetBinaryOperator("-").Evaluate(rezName, rez);
//}
//else
//{
// rez = new RemoveDelegate((IInvokable)rez);
//}
nameExpr.Assign(rez, context);
return(rez);
}
private Node EvaluateUnaryExpression(Node node, IOperator @operator, IToken token)
{
var operand = node.Accept(this) as LiteralNode;
var nodeValue = _valueFactory.CreateValueFromString(operand.Value, operand.Type);
return(new LiteralNode(token, @operator.Evaluate(nodeValue).ToString(), QLType.Undefined));
}
public override void Evaluate(IScriptContext context)
{
// ( Expr )
if (_typeExpr == null)
{
_expr.Evaluate(context);
}
// (Type) Expr
else
{
_typeExpr.Evaluate(context);
var type = context.Result as Type;
if (type == null)
{
//NOTE: Handling special case of unary minus operator:
// (3+2)-2;
var unary = _expr as ScriptUnaryExpr;
if (unary == null || unary.OperationSymbol != "-")
{
throw new ScriptSyntaxErrorException(Strings.TypeExpressionIsNotSyntacticallyCorrect);
}
//NOTE: expr + (unary expr)
var left = context.Result;
unary.Evaluate(context);
context.Result = _operator.Evaluate(left, context.Result);
return;
}
_expr.Evaluate(context);
context.Result = RuntimeHost.Binder.ConvertTo(context.Result, type);
}
}
public override void Evaluate(IScriptContext context)
{
// ( Expr )
if (typeExpr == null)
{
expr.Evaluate(context);
}
// (Type) Expr
else
{
typeExpr.Evaluate(context);
Type type = context.Result as Type;
if (type == null)
{
//NOTE: Handling special case of unary minus operator:
// (3+2)-2;
ScriptUnaryExpr unary = expr as ScriptUnaryExpr;
if (unary == null || unary.OperationSymbol != "-")
{
throw new ScriptException("Wrong type expression!");
}
//NOTE: expr + (unary expr)
object left = context.Result;
unary.Evaluate(context);
context.Result = @operator.Evaluate(left, context.Result);
return;
}
expr.Evaluate(context);
context.Result = RuntimeHost.Binder.ConvertTo(context.Result, type);
}
}
private Node EvaluateBinaryExpression(Node leftOperandNode, Node rightOperandNode, IOperator @operator, IToken token)
{
var leftOperandLiteral = leftOperandNode.Accept(this) as LiteralNode;
var rightOperandLiteral = rightOperandNode.Accept(this) as LiteralNode;
var leftValue = _valueFactory.CreateValueFromString(leftOperandLiteral.Value, leftOperandLiteral.Type);
var rightValue = _valueFactory.CreateValueFromString(rightOperandLiteral.Value, rightOperandLiteral.Type);
return(new LiteralNode(token, @operator.Evaluate(leftValue, rightValue).ToString(), QLType.Undefined));
}
private object PlusEqual(IScriptContext context)
{
var rez = context.Result;
_nameExpr.Evaluate(context);
var rezName = context.Result;
var handling = OnHandleOperator(this, context, "+=", rezName, rez);
rez = handling.Cancel ? handling.Result : _plus.Evaluate(rezName, rez);
//TODO: Events!
//if (!(rezName is EventInfo))
//{
// rez = RuntimeHost.GetBinaryOperator("+").Evaluate(rezName, rez);
//}
_nameExpr.Assign(rez, context);
return(rez);
}
public override void Evaluate(IScriptContext context)
{
left.Evaluate(context);
var leftVal = context.Result;
context.Result = RuntimeHost.NullValue;
var name = (ScriptTypeExpr)right;
name.Evaluate(context);
var rightVal = context.Result;
context.Result = _operator.Evaluate(leftVal, rightVal);
}
private bool EvaluateNode <T>(ExpressionTreeNode node, T target, IEnumerable <IValidationCondition> validationConditions)
{
if (!node.Token.IsOperatorToken())
{
IIdentifier identifier = (IIdentifier)node.Token;
IValidationCondition validationCondition = validationConditions.FirstOrDefault(r => r.ValidationConditionID == identifier.ID);
return(EvaluateValidationCondition(target, validationCondition));
}
else
{
IOperator op = (IOperator)node.Token;
return(op.Evaluate(() => EvaluateNode(node.Left, target, validationConditions),
() => EvaluateNode(node.Right, target, validationConditions)));
}
}
public override void Evaluate(IScriptContext context)
{
object leftVal, rightVal;
HandleOperatorArgs handling;
left.Evaluate(context);
leftVal = context.Result;
context.Result = RuntimeHost.NullValue;
if ((oper == "&&" && false.Equals(leftVal)) || (oper == "||" && true.Equals(leftVal)))
{
handling = OnHandleOperator(this, context, oper, leftVal);
if (handling.Cancel)
{
context.Result = handling.Result;
}
else
{
context.Result = leftVal;
}
return;
}
right.Evaluate(context);
rightVal = context.Result;
handling = OnHandleOperator(this, context, oper, leftVal, rightVal);
if (handling.Cancel)
{
context.Result = handling.Result;
}
else
{
context.Result = operatorFunction.Evaluate(leftVal, rightVal);
//RuntimeHost.GetBinaryOperator(oper).Evaluate(leftVal, rightVal);
//RuntimeHost.GetBinaryOperator(oper).Evaluate(leftVal, rightVal);
}
//Context.EvaluateOperator(oper, leftVal, rightVal);
}
private void CompleteEvaluate(IScriptContext context)
{
HandleOperatorArgs handling;
left.Evaluate(context);
var leftVal = context.Result;
context.Result = RuntimeHost.NullValue;
if ((Oper == "&&" && false.Equals(leftVal)) || (Oper == "||" && true.Equals(leftVal)))
{
handling = OnHandleOperator(this, context, Oper, leftVal);
context.Result = handling.Cancel ? handling.Result : leftVal;
return;
}
right.Evaluate(context);
var rightVal = context.Result;
handling = OnHandleOperator(this, context, Oper, leftVal, rightVal);
context.Result = handling.Cancel ? handling.Result : OperatorFunction.Evaluate(leftVal, rightVal);
}
public override int Execute(IScriptContext context)
{
_stack.Push(_operation.Evaluate(_stack.Pop(), _stack.Pop()));
return(1);
}
