public CompoundAssignmentInstruction(OpCode opCode, CompoundAssignmentType compoundAssignmentType, ILInstruction target, ILInstruction value)
: base(opCode)
{
this.CompoundAssignmentType = compoundAssignmentType;
this.Target = target;
this.Value = value;
}
public bool IsLifted => false; // TODO: implement lifted user-defined compound assignments
public UserDefinedCompoundAssign(IMethod method, CompoundAssignmentType compoundAssignmentType, ILInstruction target, ILInstruction value)
: base(OpCode.UserDefinedCompoundAssign, compoundAssignmentType, target, value)
{
this.Method = method;
Debug.Assert(Method.IsOperator || IsStringConcat(method));
Debug.Assert(compoundAssignmentType == CompoundAssignmentType.EvaluatesToNewValue || (Method.Name == "op_Increment" || Method.Name == "op_Decrement"));
Debug.Assert(IsValidCompoundAssignmentTarget(Target));
}
public CompoundAssignmentInstruction(BinaryNumericOperator op, ILInstruction target, ILInstruction value, IType type, bool checkForOverflow, Sign sign, CompoundAssignmentType compoundAssigmentType)
: base(OpCode.CompoundAssignmentInstruction)
{
this.CheckForOverflow = checkForOverflow;
this.Sign = sign;
this.Operator = op;
this.Target = target;
this.type = type;
this.Value = value;
this.CompoundAssignmentType = compoundAssigmentType;
Debug.Assert(compoundAssigmentType == CompoundAssignmentType.EvaluatesToNewValue || (op == BinaryNumericOperator.Add || op == BinaryNumericOperator.Sub));
Debug.Assert(IsValidCompoundAssignmentTarget(Target));
}
public CompoundAssignmentInstruction(BinaryNumericInstruction binary, ILInstruction target, ILInstruction value, IType type, CompoundAssignmentType compoundAssignmentType)
: base(OpCode.CompoundAssignmentInstruction)
{
Debug.Assert(IsBinaryCompatibleWithType(binary, type));
this.CheckForOverflow = binary.CheckForOverflow;
this.Sign = binary.Sign;
this.LeftInputType = binary.LeftInputType;
this.RightInputType = binary.RightInputType;
this.UnderlyingResultType = binary.UnderlyingResultType;
this.Operator = binary.Operator;
this.CompoundAssignmentType = compoundAssignmentType;
this.IsLifted = binary.IsLifted;
this.Target = target;
this.type = type;
this.Value = value;
this.ILRange = binary.ILRange;
Debug.Assert(compoundAssignmentType == CompoundAssignmentType.EvaluatesToNewValue || (Operator == BinaryNumericOperator.Add || Operator == BinaryNumericOperator.Sub));
Debug.Assert(IsValidCompoundAssignmentTarget(Target));
}
private AstNode CompoundAssignment(string identifier, CompoundAssignmentType type)
{
var variable = Variable(identifier);
int line = 0;
switch (type)
{
case CompoundAssignmentType.Add:
Match(TokenType.CompoundAdd);
break;
case CompoundAssignmentType.Subtract:
Match(TokenType.CompoundSubtract);
break;
case CompoundAssignmentType.Multiply:
Match(TokenType.CompoundMultiply);
break;
case CompoundAssignmentType.Divide:
Match(TokenType.CompoundDivide);
break;
case CompoundAssignmentType.Modulo:
Match(TokenType.CompoundModulo);
break;
default:
throw new ParserException("Unexpected compound assignment type enum value??");
}
var right = Comparison();
return(new CompoundAssignmentNode(variable, right, type)
{
Line = line
});
}
private DynValue HandleCompoundOperation(DynValue variable, DynValue operand, CompoundAssignmentType type)
{
switch (type)
{
case CompoundAssignmentType.Add:
return(new DynValue(variable.Number + operand.Number));
case CompoundAssignmentType.Subtract:
return(new DynValue(variable.Number - operand.Number));
case CompoundAssignmentType.Multiply:
return(new DynValue(variable.Number * operand.Number));
case CompoundAssignmentType.Divide:
if (operand.Number == 0)
{
throw new RuntimeException("Cannot divide by zero.", null);
}
return(new DynValue(variable.Number / operand.Number));
case CompoundAssignmentType.Modulo:
return(new DynValue(variable.Number % operand.Number));
default:
throw new RuntimeException("Unexpected compound assignment type??", null);
}
}
public CompoundAssignmentNode(VariableNode variable, AstNode right, CompoundAssignmentType operation)
{
Variable = variable;
Right = right;
Operation = operation;
}