//decode instruction based on 'code' parent variable and returns populated version of itself
public override Instruction Decode()
{
IBit = TestFlag(code, 25);
P = TestFlag(code, 24);
U = TestFlag(code, 23);
S = TestFlag(code, 22);
W = TestFlag(code, 21);
L = TestFlag(code, 20);
Rn = (char)ExtractBits(code, 16, 19);
address = Regs.ReadWord(GetReg(Rn));
regstr = "";
bool first = true;
for (int i = 0; i < regList.Length; i++)
{
regList[i] = TestFlag(code, i);
if (regList[i])
{
if (!first)
{
regstr += ", ";
}
regstr += "r" + i;
first = false;
}
}
return(this);
}
/// <summary> Получение информации об изделии из БД </summary>
public Product GetProductInfo(string ProductID)
{
for (int i = 0; i < Prods.Count; i++)
{
Product p = (Product)Prods[i];
if (p.ID == ProductID)
{
if (p.Registrations == null)
{
return(new Product(p.ID, p.ModelID, p.Model, null));
}
ArrayList Regs = null;
for (int j = 0; j < p.Registrations.Count; j++)
{
Registration r = (Registration)p.Registrations[j];
if (DateTime.Now < r.Time.Add(ProgramSettings.ReentrancePeriod))
{
r = new Registration(r.Time, r.Line, r.DeffectID, r.WorkerID, r.IsChanged);
if (Regs == null)
{
Regs = new ArrayList();
}
Regs.Add(r);
}
}
return(new Product(p.ID, p.ModelID, p.Model, Regs));
}
}
return(null);
}
//Extract adress according to register offset specification
int DecodeRegisterOffset()
{
char Rm = (char)ExtractBits(code, 0, 3);
char Sh = (char)ExtractBits(code, 5, 6);
int shiftVal = ExtractBits(code, 7, 11);
shiftVal *= U ? 1 : -1;
stringValue = ", " + (shiftVal == 0 ? (U ? "" : "-") : "") + "r" + (int)Rm;
int regval = Regs.ReadWord(GetReg(Rm));
if (Rm == 15)
{
regval += 8;
}
if (shiftVal != 0)
{
stringValue += ", " + BarrelShifter.CodeToString(Sh) + " #" + shiftVal;
}
else if (!U)
{
regval *= -1;
}
return(BarrelShifter.ShiftByCode(regval, shiftVal, Sh));
}
public static Operand GetMemory(Regs reg, int value)
{
return(new Operand()
{
OperandType = OperandType.Mem, Value = new Nbit(4, (int)reg) << 28 | new Nbit(28, value).Value
});
}
public static Operand GetRegister(Regs reg)
{
return(new Operand()
{
OperandType = OperandType.Reg, Value = (int)reg
});
}
//fire the interrupt
//Interrupts are special. They get special access to the inner guts of the program...
public override void Execute()
{
if (swiType == 0x11)
{
Flags[SysFlag.Running] = false;
Flags[SysFlag.Unsteppable] = true;
return;
}
Regs.WriteWord(Reg.LR_SVC, Regs.ReadWord(Reg.R15));
Regs.WriteWord(Reg.SPSR_SVC, Regs.ReadWord(Reg.CPSR));
int cpsr = Regs.ReadWord(Reg.CPSR) & 0b1111111111111111111111111100000;
Regs.WriteWord(Reg.CPSR, cpsr | Mode.Supervisor); //switch to superviser
if (swiType == 0x0)
{
SetCPSRFlag(7, true);
}
else
{
SetCPSRFlag(7, false);
}
Regs.WriteWord(Reg.R15, 0x8);
}
//All these operations are unique in their own ways and I cannot simplify them into one function,
//they all need their own functions. They are also highly dependent on the same instance variables, therefore
//making a utilities class would mean many unnecessary arguments.
//All the operations:
//move value of op3 into Rd
void MOV()
{
Regs.WriteWord(GetReg(Rd), op3);
if (SBit && Rd == 15)
{
SwitchBackMode();
}
}
private void ImgOzviat_MouseLeftButtonDown_1(object sender, MouseButtonEventArgs e)
{
// add tabitem
Regs reg = new Regs();
reg.Show();
this.Hide();
}
//loads the values in the address pointed to by Rn into the active registers
//in reglist[] while incrementing the address in Rn after loading
void Load() //pop
{
for (int i = 0; i < regList.Length; i++)
{
if (regList[i])
{
Regs.WriteWord(GetReg(i), RAM.ReadWord(address));
address += 4;
}
}
}
//Loads value pointed to by 'address' into register Rd
void Load()
{
if (B)
{
Regs.WriteWord(GetReg(Rd), RAM.ReadByte(address));
}
else
{
Regs.WriteWord(GetReg(Rd), RAM.ReadWord(address));
}
}
//Extract the operands op1, op2, op3 from the command
void CalculateOperands()
{
opn = Regs.ReadWord(GetReg(Rn)); //What is stored in Rn
if (Rn == 15)
{
opn += 8;
}
opd = Regs.ReadWord(GetReg(Rd)); //What is stored in Rd
op3 = IBit ? CalulateImmediateOperand3() : CalculateRegisterOperand3();
}
//stores the values in the active registers in reglist[] into the address pinted to by Rn
//while decrementing the value Rn before the store process
void Store() //push
{
for (int i = regList.Length - 1; i >= 0; i--)
{
if (regList[i])
{
address -= 4;
RAM.WriteWord(address, Regs.ReadWord(GetReg(i)));
}
}
}
private void SetSelectEffect(Regs reg, bool b)
{
var ItemContainer = gridView2.ContainerFromItem(reg);
var selectedItem = ItemContainer as ListViewItem;
if (selectedItem != null)
{
var grid = selectedItem.ContentTemplateRoot as Grid;
var block = (TextBlock)VisualTreeHelper.GetChild(grid, 0);
block.Foreground = b ? new SolidColorBrush(Colors.Yellow) : (Application.Current.Resources["SystemColorWindowTextColor"] as SolidColorBrush);
//(IsLightTheme() ? new SolidColorBrush(Colors.Black) : new SolidColorBrush(Colors.White))
}
}
//Change the value of the program counter,
//if L is true, store previous PC value in R14
public override void Execute()
{
if (isRet)
{
ExecuteReturn();
return;
}
if (link)
{
Regs.WriteWord(GetReg(14), Regs.ReadWord(Reg.R15));
}
Regs.WriteWord(Reg.R15, address);
}
//caculated and returns the reister operand
int CalulateRegValue()
{
char Rm = (char)ExtractBits(code, 0, 3);
int val = Regs.ReadWord(GetReg(Rm));
if (Rm == 15)
{
val += 8;
}
strVal = "r" + (int)Rm;
return(val);
}
//Transfers value from CPSR or SPSR of the current mode into a general purpose register
public override void Execute()
{
int value = Regs.ReadWord(Reg.CPSR);
if (RBit)
{
char mode = CheckMode();
if (mode == 'V') //supervisor
value = Regs.ReadWord(Reg.LR_SVC);
else if (mode == 'R') //irq
value = Regs.ReadWord(Reg.LR_IRQ);
}
Regs.WriteWord(GetReg(Rd), value);
}
//Executes instruction by either store or load
public override void Execute()
{
if (L)
{
Load();
}
else
{
Store();
}
if (W)
{
Regs.WriteWord(GetReg(Rn), address);
}
}
//Calculate the address to jump to relative to PC
void ProcessBranchAddress()
{
int pc = Regs.ReadWord(Reg.R15);
link = TestFlag(code, 24);
sign = TestFlag(code, 23);
offset = ExtractBits(code, 0, 22);
if (sign)
{
uint mask = 0xFFF00000;
offset |= (int)mask; //mask to convert to signed FF000000
}
offset <<= 2;
address = pc + 8 + offset;
}
public uint Get(Regs reg)
{
switch (reg)
{
case Regs.EAX: return(EAX);
case Regs.EBX: return(EBX);
case Regs.ECX: return(ECX);
case Regs.EDX: return(EDX);
case Regs.ESP: return(ESP);
case Regs.EBP: return(EBP);
}
throw new ArgumentException("Unknown register");
}
//transfers the value of a general-purpose register or an
//immediate constant to the CPSR or the SPSR of the current mode.
public override void Execute()
{
if (RBit)
{
char mode = CheckMode();
if (mode == 'V')
{ //supervisor
Regs.WriteWord(Reg.SPSR_SVC, value);
}
else if (mode == 'R')
{ //irq
Regs.WriteWord(Reg.SPSR_IRQ, value);
}
}
else
{
Regs.WriteWord(Reg.CPSR, value);
}
}
//Stores value from register Rd in 'address'
void Store()
{
if (B)
{
int storeVal = Regs.ReadWord(GetReg(Rd));
if (Rd == 15)
{
storeVal += 8;
}
RAM.WriteByte(address, (byte)storeVal);
}
else
{
int storeVal = Regs.ReadWord(GetReg(Rd));
if (Rd == 15)
{
storeVal += 8;
}
RAM.WriteWord(address, storeVal);
}
}
//Calcultes and returns the register shift operand
int CalculateRegisterOperand3()
{
int shiftVal;
Rm = (char)ExtractBits(code, 0, 3);
char Sh = (char)ExtractBits(code, 5, 6);
bool bit4 = TestFlag(code, 4);
char Rs = '0';
strShift = "r" + (int)Rm;
if (!bit4)
{
shiftVal = ExtractBits(code, 7, 11);
}
else
{
Rs = (char)ExtractBits(code, 8, 11);
shiftVal = Regs.ReadWord(GetReg(Rs));
if (Rs == 15)
{
shiftVal += 8;
}
}
if (shiftVal != 0)
{
strShift += ", " + BarrelShifter.CodeToString(Sh) + (bit4 ? " r" + (int)Rs : " #" + shiftVal);
}
int val = Regs.ReadWord(GetReg(Rm));
if (Rm == 15)
{
val += 8;
}
return(BarrelShifter.ShiftByCode(val, shiftVal, Sh));
}
/// <returns>Register was changed</returns>
public bool Set(Regs reg, uint value)
{
uint old;
switch (reg)
{
case Regs.EAX: old = EAX; EAX = value; break;
case Regs.EBX: old = EBX; EBX = value; break;
case Regs.ECX: old = ECX; ECX = value; break;
case Regs.EDX: old = EDX; EDX = value; break;
case Regs.ESP: old = ESP; ESP = value; break;
case Regs.EBP: old = EBP; EBP = value; break;
default:
throw new ArgumentException("Unknown register");
}
return(old != value);
}
//Decodes loadstore instruction for 'code' parent variable and returns
//itself as a fully populated instruction ready for execution
public override Instruction Decode()
{
IBit = TestFlag(code, 25);
P = TestFlag(code, 24);
U = TestFlag(code, 23);
B = TestFlag(code, 22);
W = TestFlag(code, 21);
L = TestFlag(code, 20);
Rn = (char)ExtractBits(code, 16, 19);
Rd = (char)ExtractBits(code, 12, 15);
int regContent = Regs.ReadWord(GetReg(Rn));
if (Rn == 15)
{
regContent += 8;
}
offset = !IBit?DecodeImmediateOffset() : DecodeRegisterOffset();
address = P ? regContent + offset : regContent;
return(this);
}
public Regs RegsGrid(String CemexId)
{
Regs userse = new Regs();
var param = new List<SqlParameter>();
param.Add(new SqlParameter("@CemexId", CemexId));
IRdmsConnection cnn = new SqlRdmsConnection<UserIdDTO>(UtilSh.strCnn2, "dbo.GetPermission", param);
var result = cnn.Execute(true, CommandType.StoredProcedure);
var res = (from r in result
select (UserIdDTO)r).ToArray();
param.Clear();
string connectionString = UtilSh.strCnn2;/* System.Configuration.ConfigurationManager.ConnectionStrings["cnnSql2"].ToString();*/
using (SqlConnection connection = new SqlConnection(connectionString))
{
using (SqlCommand command = new SqlCommand())
{
command.Connection = connection;
command.CommandText = "Exec dbo.RegsGrid @User="******"ID"]);
user.Llave = Convert.ToString(dataReader["Llave"]);
user.CodCliente = Convert.ToString(dataReader["CodCliente"]);
user.NCliente = Convert.ToString(dataReader["NCliente"]);
user.Pais = Convert.ToString(dataReader["Pais"]);
user.Cupo = Convert.ToString(dataReader["Cupo"]);
user.CupoOtorgado = Convert.ToString(dataReader["CupoOtorgado"]);
user.Plazo = Convert.ToString(dataReader["Plazo"]);
user.PlazoOtorgado = Convert.ToString(dataReader["PlazoOtorgado"]);
user.Tipo = Convert.ToString(dataReader["Tipo"]);
user.Estado = Convert.ToString(dataReader["Estado"]);
user.Vice = Convert.ToString(dataReader["Vice"]);
user.SolCre = Convert.ToString(dataReader["SolCre"]);
user.Pagare = Convert.ToString(dataReader["Pagare"]);
user.Cedula = Convert.ToString(dataReader["Cedula"]);
user.Camara = Convert.ToString(dataReader["Camara"]);
user.Rut = Convert.ToString(dataReader["Rut"]);
user.Comentarios = Convert.ToString(dataReader["Comentarios"]);
user.Fecha = Convert.ToString(dataReader["Fecha"]);
user.Hora = Convert.ToString(dataReader["Hora"]);
user.ComentarioCredito = Convert.ToString(dataReader["ComentarioCredito"]);
user.Comercial = Convert.ToString(dataReader["Comercial"]);
userse.Add(user);
}
}
//Convert.ToInt32(paramTotalRecords.Value);
}
}
/* param = new List<SqlParameter>();
param.Add(new SqlParameter("@User", CemexId));
cnn = new SqlRdmsConnection<RegDTO>(UtilSh.strCnn2, "dbo.RegsGrid",param);//Procedimiento almacenado para inserción de solicitudes.
var result2 = cnn.Execute(true, CommandType.StoredProcedure);
var res2 = (from r in result2
select (RegDTO)r).ToArray();
foreach(var x in res2)
{
userse.Add(x);
}*/
return userse;
}
private static bool x8(Regs regs)
{
return regs.e || regs.p.x;
}
public static Match Match(string input, Regs regex)
{
return Regexes[(int)regex].Match(input);
}
// Rn - op3 and store in Rd
void SUB()
{
Regs.WriteWord(GetReg(Rd), opn - op3);
}
// rn logical OR op3 store in rd
void ORR()
{
//rd = rn || op3
Regs.WriteWord(GetReg(Rd), opn | op3);
}
// op3 - Rn and store in Rd
void RSB()
{
Regs.WriteWord(GetReg(Rd), op3 - opn);
}
//bit clear rd = rn & ~op3
void BIC()
{
Regs.WriteWord(GetReg(Rd), opn & ~op3);
}
// move NOT op3 into rd
void MVN()
{
Regs.WriteWord(GetReg(Rd), ~op3);
}
public static Regs GetUsers()
{
Regs userse = new Regs();
ServHCR shcr = new ServHCR();
userse = shcr.RegsGrid(HttpContext.Current.User.Identity.Name);
return userse;
}
private static bool a8(Regs regs)
{
return regs.e || regs.p.m;
}
disassembly : $"{(disassemble ? Disassemble(Regs[PC], ReadMemory, out _) : "---")} ".PadRight(50),
