/// <summary>
/// 复杂运算通用函数接口
/// </summary>
/// <param name="flag">运算结果标志位</param>
/// <param name="overflow">运算溢出标志位</param>
/// <param name="operation">运算类型</param>
/// <param name="parameters">传入参数列表</param>
/// <returns>返回运算结果</returns>
public sealed override byte[] ComplexCalculate(out Symbol_Flag flag, out bool overflow, string operation, CalculateParameter[] parameters)
{
Lock();
byte[] vs = Calculate(out flag, out overflow, operation, parameters);
Unlock();
return(vs);
}
protected override byte[] Calculate(out Symbol_Flag flag, out bool overflow, string operation, CalculateParameter[] parameters)
{
byte[] result = new byte[0];
flag = Symbol_Flag.Zero;
overflow = false;
return(result);
}
/// <summary>
/// 减法运算
/// </summary>
/// <param name="param1">参数1</param>
/// <param name="param2">参数2</param>
/// <param name="flag">运算结果符号标志</param>
/// <param name="overflow">运算溢出标志位</param>
/// <returns>返回运算结果</returns>
public byte[] Sub(byte[] param1, byte[] param2, out Symbol_Flag flag, out bool overflow)
{
overflow = false;
byte[] result = new byte[(param1.Length > param2.Length ? param1.Length : param2.Length)];
BigInteger integer1 = 0, integer2 = 0;
if (null != param1)
{
for (int i = param1.Length - 1; i >= 0; i--)
{
integer1 = integer1 * 256 + param1[i];
}
}
if (null != param2)
{
for (int i = param2.Length - 1; i >= 0; i--)
{
integer2 = integer2 * 256 + param2[i];
}
}
integer1 -= integer2;
if (0 == integer1)
{
flag = Symbol_Flag.Zero;
for (int i = 0; i < result.Length; i++)
{
result[i] = 0x00;
}
}
else
{
if (0 < integer1)
{
flag = Symbol_Flag.Positive;
}
else
{
flag = Symbol_Flag.Negative;
}
for (int i = 0; i < result.Length && 0 != integer1; i++, integer1 /= 256)
{
result[i] = (byte)(int)(integer1 % 256);
}
}
if (0 != integer1)
{
overflow = true;
}
return(result);
}
public byte[] Not(byte[] param, out Symbol_Flag flag)
{
byte[] result = new byte[param.Length];
BigInteger integer1 = 0;
if (null != param)
{
for (int i = param.Length - 1; i >= 0; i--)
{
integer1 = integer1 * 256 + param[i];
}
}
integer1 = ~integer1;
if (0 == integer1)
{
flag = Symbol_Flag.Zero;
for (int i = 0; i < result.Length; i++)
{
result[i] = 0x00;
}
}
else
{
if (0 < integer1)
{
flag = Symbol_Flag.Positive;
}
else
{
flag = Symbol_Flag.Negative;
}
for (int i = 0; i < result.Length && 0 != integer1; i++, integer1 /= 256)
{
result[i] = (byte)(int)(integer1 % 256);
}
}
return(result);
}
/// <summary> /// 复杂运算函数 /// </summary> /// <param name="flag">运算结果标志位</param> /// <param name="overflow">运算溢出标志位</param> /// <param name="operation">运算类型</param> /// <param name="parameters">传入参数列表</param> /// <returns>返回运算结果</returns> protected abstract byte[] Calculate(out Symbol_Flag flag, out bool overflow, string operation, CalculateParameter[] parameters);
/// <summary>
/// 运算逻辑单元构造函数
/// </summary>
/// <param name="complex">复杂运算单元接口</param>
public IALUnit(IComplexOperation complex)
{
Complex = complex;
Symbol = Symbol_Flag.Zero;
}
/// <summary> /// 复杂运算通用函数接口 /// </summary> /// <param name="flag">运算结果标志位</param> /// <param name="overflow">运算溢出标志位</param> /// <param name="operation">运算类型</param> /// <param name="parameters">传入参数列表</param> /// <returns>返回运算结果</returns> public abstract byte[] ComplexCalculate(out Symbol_Flag flag, out bool overflow, string operation, CalculateParameter[] parameters);
/// <summary>
/// 运算方法
/// </summary>
/// <param name="overflow">溢出标志位</param>
/// <param name="operation">运算符</param>
/// <param name="parameters">参数表</param>
/// <returns>返回运算结果</returns>
public override byte[] Calculate(out bool overflow, string operation, CalculateParameter[] parameters)
{
byte[] result = null;
Symbol_Flag flag = Symbol_Flag.Zero;
overflow = false;
if (null != parameters)
{
switch (operation.ToUpper())
{
case "ADD":
if (2 <= parameters.Length)
{
result = Math.Add(parameters[0].Data, parameters[1].Data, out flag, out overflow);
}
break;
case "SUB":
if (2 <= parameters.Length)
{
result = Math.Sub(parameters[0].Data, parameters[1].Data, out flag, out overflow);
}
break;
case "MUL":
if (2 <= parameters.Length)
{
result = Math.Mul(parameters[0].Data, parameters[1].Data, out flag, out overflow);
}
break;
case "DIV":
if (2 <= parameters.Length)
{
result = Math.Div(parameters[0].Data, parameters[1].Data, out flag, out overflow);
}
break;
case "MOD":
if (2 <= parameters.Length)
{
result = Math.Mod(parameters[0].Data, parameters[1].Data, out flag, out overflow);
}
break;
case "AND":
if (2 <= parameters.Length)
{
result = Logic.And(parameters[0].Data, parameters[1].Data, out flag);
}
break;
case "OR":
if (2 <= parameters.Length)
{
result = Logic.Or(parameters[0].Data, parameters[1].Data, out flag);
}
break;
case "NOT":
if (1 <= parameters.Length)
{
result = Logic.Not(parameters[0].Data, out flag);
}
break;
case "XOR":
if (2 <= parameters.Length)
{
result = Logic.Xor(parameters[0].Data, parameters[1].Data, out flag);
}
break;
default:
if (Complex.OperateTest(operation))
{
result = Complex.ComplexCalculate(out flag, out overflow, operation, parameters);
}
break;
}
}
Symbol = flag;
return(result);
}
