/// <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); }