/// <summary>
/// Initialize object
/// </summary>
/// <param name="machine"></param>
public void Run(RdlVirtualMachine machine)
{
switch (_partOfDate)
{
case PartOfDate.Seconds:
machine.Datetimes.Push(machine.Datetimes.Pop().AddSeconds(_value));
break;
case PartOfDate.Minutes:
machine.Datetimes.Push(machine.Datetimes.Pop().AddMinutes(_value));
break;
case PartOfDate.Hours:
machine.Datetimes.Push(machine.Datetimes.Pop().AddHours(_value));
break;
case PartOfDate.DaysOfMonth:
machine.Datetimes.Push(machine.Datetimes.Pop().AddDays(_value));
break;
case PartOfDate.Months:
machine.Datetimes.Push(machine.Datetimes.Pop().AddMonths(_value));
break;
case PartOfDate.Years:
machine.Datetimes.Push(machine.Datetimes.Pop().AddYears(_value));
break;
}
machine.InstructionPointer += 1;
}
/// <summary>
/// Subtract numeric values.
/// </summary>
/// <param name="machine">The virtual machine.</param>
public void Run(RdlVirtualMachine machine)
{
var b = machine.Values.Pop();
var a = machine.Values.Pop();
machine.Values.Push(a - b);
machine.InstructionPointer += 1;
}
/// <summary>
/// Performs check if the value is between other values.
/// </summary>
/// <param name="machine">The virtual machine.</param>
public void Run(RdlVirtualMachine machine)
{
var max = machine.Values.Pop();
var min = machine.Values.Pop();
var val = machine.Values.Pop();
machine.Values.Push(Convert.ToInt16(val >= min && val < max));
machine.InstructionPointer += 1;
}
/// <summary>
/// Assign instruction pointer based on label when poped from stack value is false,
/// else increment instruction pointer.
/// </summary>
/// <param name="machine">Virtual machine on that code will be executed.</param>
public void Run(RdlVirtualMachine machine)
{
if (!Convert.ToBoolean(machine.Values.Pop()))
{
machine.InstructionPointer = machine.RelativeLabels[_label];
}
else
{
machine.InstructionPointer += 1;
}
}
/// <summary>
/// Divide two numeric values stored on stack.
/// </summary>
/// <param name="machine">virtual machine that on that code will be performed</param>
public void Run(RdlVirtualMachine machine)
{
var b = machine.Values.Pop();
var a = machine.Values.Pop();
if (b == 0)
{
throw new Exceptions.DivideByZeroException();
}
machine.Values.Push(a / b);
machine.InstructionPointer += 1;
}
public void Run(RdlVirtualMachine machine)
{
switch (_state)
{
case ExpressionState.Before:
_expBeginCallback(_node, machine);
break;
case ExpressionState.After:
_expEndCallback(_node, machine);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Performs "generic in" comparsion. Get how much arguments, pop reference value, and compare
/// each poped value from stack with such reference value. If one of them match, then push true, else false.
/// This operation push it's result to numeric stack.
/// </summary>
/// <param name="machine"></param>
public void Run(RdlVirtualMachine machine)
{
var inArgsCount = machine.Registers[(short)Registers.B];
var toCompare = _pop(machine);
var result = false;
var i = 0;
for (; i < inArgsCount && !result; ++i)
{
var tmpRes = _pop(machine);
result |= tmpRes.Equals(toCompare);
}
for (; i < inArgsCount; ++i)
{
_pop(machine);
}
machine.Values.Push(result ? 1 : 0);
machine.InstructionPointer += 1;
}
/// <summary>
/// Perform negate operation on value.
/// </summary>
/// <param name="machine">The virtual machine.</param>
public void Run(RdlVirtualMachine machine)
{
machine.Values.Push(Convert.ToInt64(!Convert.ToBoolean(machine.Values.Pop())));
machine.InstructionPointer += 1;
}
/// <summary>
/// Perform stored function to retrieve variable from memory and push it on stack.
/// </summary>
/// <param name="machine">The virtual machine.</param>
public void Run(RdlVirtualMachine machine)
{
machine.Values.Push(_loadFun(machine.Variables));
machine.InstructionPointer += 1;
}
/// <summary>
/// Copies invocation result to memory.
/// </summary>
/// <param name="machine">The virtual machine.</param>
public void Run(RdlVirtualMachine machine)
{
machine.Variables[_registeredFunction.ToString()] = _storeValueFunc(machine);
machine.InstructionPointer += 1;
}
/// <summary>
/// Determine if two datetime values stored on stack are the same
/// </summary>
/// <param name="machine">virtual machine that on that code will be performed</param>
public void Run(RdlVirtualMachine machine)
{
machine.Values.Push(Convert.ToInt16(machine.Datetimes.Pop() != machine.Datetimes.Pop()));
machine.InstructionPointer += 1;
}
/// <summary>
/// Breaks virtual code execution
/// </summary>
/// <param name="machine"></param>
public void Run(RdlVirtualMachine machine)
{
machine.Break = true;
machine.InstructionPointer += 1;
}
/// <summary>
/// Performs call on object.
/// </summary>
/// <param name="machine"></param>
public void Run(RdlVirtualMachine machine)
{
var parameters = _infoParameters;
var args = new List <object>();
foreach (var attribute in _toInjectAttributes)
{
switch (attribute.GetType().Name)
{
case nameof(InjectReferenceTimeAttribute):
args.Add(machine.ReferenceTime);
break;
case nameof(InjectLastFireAttribute):
args.Add(machine.LastFireTime);
break;
case nameof(InjectPartOfDateTypeAttribute):
args.Add(_partOfDate);
break;
case nameof(InjectOccurenceOrderAttribute):
args.Add(_functionOrder);
break;
case nameof(InjectOccurencesAmountAttribute):
args.Add(_functionOccurenceAmount);
break;
case nameof(InjectStartAtAttribute):
args.Add(machine.StartAt);
break;
case nameof(InjectStopAtAttribute):
args.Add(machine.StopAt);
break;
}
}
var normalParams = _withoutInjectParameters;
for (var i = 0; i < normalParams.Length && i < _callParamsCount; i++)
{
var type = normalParams[i];
switch (type.ParameterType.GetUnderlyingNullable().Name)
{
case nameof(DateTimeOffset):
args.Add(machine.Datetimes.Pop());
break;
case nameof(String):
args.Add(machine.Strings.Pop());
break;
case nameof(Int64):
args.Add(machine.Values.Pop());
break;
case nameof(Int32):
args.Add(Convert.ToInt32(machine.Values.Pop()));
break;
case nameof(Int16):
args.Add(Convert.ToInt16(machine.Values.Pop()));
break;
case nameof(Boolean):
args.Add(Convert.ToBoolean(machine.Values.Pop()));
break;
default:
throw new Exception();
}
}
var countOfUnsetParameters = parameters.Length - args.Count;
if (countOfUnsetParameters > parameters.CountOptionalParameters())
{
throw new ArgumentException();
}
for (int i = 0, j = parameters.Length - countOfUnsetParameters; i < countOfUnsetParameters; ++i)
{
var param = parameters[j + i];
args.Add(param.HasDefaultValue ? param.DefaultValue : Type.Missing);
}
var result = _info.Invoke(_obj, args.ToArray());
switch (_info.ReturnType.GetUnderlyingNullable().Name)
{
case nameof(DateTimeOffset):
machine.Datetimes.Push((DateTimeOffset)result);
break;
case nameof(String):
machine.Strings.Push((string)result);
break;
case nameof(Boolean):
case nameof(Int16):
case nameof(Int32):
case nameof(Int64):
machine.Values.Push(Convert.ToInt64(result));
break;
}
machine.InstructionPointer += 1;
}
/// <summary>
/// Performs comparsion betwen two numeric values in stack and determine if it's less
/// </summary>
/// <param name="machine">The virtual machine</param>
public void Run(RdlVirtualMachine machine)
{
machine.Values.Push(machine.Datetimes.Pop() > machine.Datetimes.Pop() ? 1 : 0);
machine.InstructionPointer += 1;
}
/// <summary>
/// Sets new instruction pointer value.
/// </summary>
/// <param name="machine">virtual machine that on that code will be performed</param>
public void Run(RdlVirtualMachine machine)
{
machine.InstructionPointer = _newInstructionPtr;
}
/// <summary>
/// Assign instruction pointer based on label.
/// </summary>
/// <param name="machine">Virtual machine on that code will be executed.</param>
public void Run(RdlVirtualMachine machine)
{
machine.InstructionPointer = machine.RelativeLabels[_label];
}
/// <summary>
/// Performs modyfication on reference time.
/// </summary>
/// <param name="machine">The virtual machine.</param>
public void Run(RdlVirtualMachine machine)
{
machine.ReferenceTime = _fun(machine.ReferenceTime);
machine.InstructionPointer += 1;
}
/// <summary>
/// Push value onto the stack.
/// </summary>
/// <param name="machine">The virtual machine.</param>
public void Run(RdlVirtualMachine machine)
{
machine.Values.Push(_value);
machine.InstructionPointer += 1;
}
/// <summary>
/// Assign value to one of registers.
/// </summary>
/// <param name="machine">The virtual machine.</param>
public void Run(RdlVirtualMachine machine)
{
machine.Registers[(short)_register] = _value;
machine.InstructionPointer += 1;
}
