Материалы по Архитектуре / Приложение 1

using System;

using System.Collections.Generic;

using System.Collections;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using System.IO;

namespace risc

{

public partial class Form1 : Form

{

RichTextBox richTextBox1;

DataGridView R1;

DataGridView R2;

DataGridViewRow rows;

ArrayList List16 = new ArrayList();

ArrayList List16_3 = new ArrayList();

ArrayList List32 = new ArrayList();

int cap = 0;

int com = 0;

int opcap;

int src1;

int src2;

int imm;

int imm2;

string tt;

private bool com32(string tok)

{

// команды 16-разрядные

foreach (string i in List32)

if (i == tok)

return true;

return false;

}

private bool com161(string tok)

{

// команды 16-разрядные

foreach (string i in List16)

if (i == tok)

{

//cap = 161;

return true;

}

return false;

}

private bool com163(string tok)

{

// команды 16-разрядные

foreach (string i in List16_3)

if (i == tok)

{

//cap = 162;

return true;

}

return false;

}

private bool com16(string tok)

{

// команды 16-разрядные

if (com161(tok))

return true;

if (com163(tok))

return true;

return false;

}

private void Ini()

{

this.RG0.Rows.Add("0", "00000000", "00000000", "00000000", "00000000", "00000000", "00000000", "00000000", "00000000");

this.RG0.ClearSelection();

this.RG1.Rows.Add("1", "00000000000000000000000000000000", "00000000000000000000000000000000");

this.RG1.ClearSelection();

this.RG2.Rows.Add("2", "00000000000000000000000000000000", "00000000000000000000000000000000");

this.RG2.ClearSelection();

this.RG3.Rows.Add("3", "0000000000000000000000000000000000000000000000000000000000000000");

this.RG3.ClearSelection();

this.RG4.Rows.Add("4", "0000000000000000000000000000000000000000000000000000000000000000");

this.RG4.ClearSelection();

this.RG5.Rows.Add("5", "0000000000000000000000000000000000000000000000000000000000000000");

this.RG5.ClearSelection();

this.RG6.Rows.Add("6", "0000000000000000000000000000000000000000000000000000000000000000");

this.RG6.ClearSelection();

this.RG7.Rows.Add("7", "0000000000000000000000000000000000000000000000000000000000000010");

this.RG7.ClearSelection();

this.dataGridViewOP.Rows.Add("2", "0000000000000000000000000000111000000000000000011100000000011000");

this.dataGridViewOP.ClearSelection();

richTextBox1 = new System.Windows.Forms.RichTextBox();

//16 разрядные команды

List16.Add("add");

List16.Add("adc");

List16.Add("sub");

List16.Add("sbc");

List16.Add("mul");

List16.Add("and");

List16.Add("or");

List16.Add("xor");

List16.Add("cp");

List16_3.Add("cpl");

List16_3.Add("lddw");

List16_3.Add("ldw");

List16_3.Add("ldb");

List16_3.Add("stdw");

List32.Add("jz");

List32.Add("jnz");

}

public Form1()

{

InitializeComponent();

Ini();

}

private void Cmd_CellContentClick(object sender, DataGridViewCellEventArgs e)

{

}

private void button1_Click(object sender, EventArgs e)

{

if (richTextBox1.Text.Length != 0)

{

richTextBox1.Text.Remove(0);

}

OpenFileDialog openFileDialog1 = new OpenFileDialog();

openFileDialog1.InitialDirectory = "C:\\";

openFileDialog1.Filter = "Текстовые файлы(*.txt)|*.txt";

if (openFileDialog1.ShowDialog() == DialogResult.OK)

{

Stream stream = openFileDialog1.OpenFile();

richTextBox1.LoadFile(stream, RichTextBoxStreamType.PlainText);

stream.Close();

}

string[] tokens = richTextBox1.Text.Split(new char[] { ' ', '\t', ',', '\n', ';' }, StringSplitOptions.RemoveEmptyEntries);

int lenghtOfSimbol = tokens.Length;

int numofcom = 0;

labelPC1.Text = numofcom.ToString();

for (int i = 0; i < lenghtOfSimbol; i++)

{

if (com16(tokens[i]))

{

Cmd.Rows.Add(numofcom, tokens[i], tokens[i + 1], tokens[i+2], tokens[i+3],"0",tokens[i+4]);

i += 4;

}

else

{

if (com32(tokens[i]))

{

Cmd.Rows.Add(numofcom, tokens[i], tokens[i + 1], tokens[i + 2], tokens[i + 3], tokens[i + 4], tokens[i + 5]);

i += 5;

}

}

numofcom+=4;

}

}

private void op()

{

if (cap == 1)

{

if (src1 >= 100)

{

src1 = src1 - 100;

opcap = 64;

}

else

opcap = 32;

if (src2 >= 100)

{

src2 = src2 - 100;

opcap = 64;

}

}

else

{

opcap = 8;

}

}

private void opr()

{

switch (imm)

{

case 11:

{

op();

break;

}

case 00:

case 01:

{

int s = src1 * 1000 + src2;

if (s < 1000)

opcap = 8;

else

if (s < 1100)

opcap = 32;

else

opcap = 64;

break;

}

case 10:

{

op();

src2 = 0;

break;

}

}

}

private long toD(string str)

{

int l=str.Length;

long res=0;

for (int i = 0; i < l; i++)

res +=(long)(long.Parse(str[i].ToString()) * System.Math.Pow(2.0, l - i - 1));

return res;

}

private string bitarrayout(BitArray ba)

{

string res="";

for (int i = 0; i < ba.Length; i++)

{

if(ba[i]==false)

res = res + "0";

else

res = res + "1";

}

return res;

}

private void toDD(BitArray ba,long op)

{

int l=ba.Count;

long ost = op;

for (int i = 0; i < (l-1); i++)

{

if ( ost%2 == 0)

ba[l-i-1] = false;

else

ba[l-i-1] = true;

if (ost == 1 || ost == 0)

break;

ost = ost / 2;

}

}

DataGridView reg64(long r1)

{

switch (r1)

{

case 0: return RG3;

case 1: return RG4;

case 2: return RG5;

case 3: return RG6;

}

return RG7;

}

private void Program()

{

//выполнение команды

labelPC1.Text = rows.Cells[0].Value.ToString();

tt = rows.Cells[1].Value.ToString();

cap = int.Parse(rows.Cells[2].Value.ToString());

imm = int.Parse(rows.Cells[3].Value.ToString());

src1 = int.Parse(rows.Cells[4].Value.ToString());

imm2 = int.Parse(rows.Cells[5].Value.ToString());

src2 = int.Parse(rows.Cells[6].Value.ToString());

int pc = int.Parse(labelPC1.Text) + 4;

labelPC1.Text = pc.ToString();

com = int.Parse(labelPC1.Text)/4;

switch (tt)

{

case "add":

{

// дешифрация остальных операндов

opr();

// выполнение операции add

if (opcap == 8)

{

// определение регистров

int r1 = 8 - (int)toD(src1.ToString());

int r2 = 8 - (int)toD(src2.ToString());

long op1 = toD(RG0.Rows[0].Cells[r1].Value.ToString());

long op2 = toD(RG0.Rows[0].Cells[r2].Value.ToString());

long op = op1 + op2;

if (op == 0)

Z.Checked = true;

BitArray ba = new BitArray(8);

toDD(ba, op);

string s = bitarrayout(ba);

RG0.Rows[0].Cells[r1].Value = s;

}

if (opcap == 32)

{

int r1 = (int)toD(src1.ToString());

int r2 = (int)toD(src2.ToString());

if (r1 > 1)

{

R1 = RG2;

r1 = r1 - 2;

}

else

R1 = RG1;

if(r2>1)

{

R2 = RG2;

r2 = r2 - 2;

}

else

R2 = RG1;

long op1 = toD(R1.Rows[0].Cells[2-r1].Value.ToString());

long op2 = toD(R2.Rows[0].Cells[2-r2].Value.ToString());

long op = op1 + op2;

if (op == 0)

Z.Checked = true;

BitArray ba = new BitArray(32);

toDD(ba, op);

string s = bitarrayout(ba);

R1.Rows[0].Cells[2-r1].Value = s;

}

if (opcap == 64)

{

long r1 = toD(src1.ToString());

long r2 = toD(src2.ToString());

R1=reg64(r1);

R2=reg64(r2);

long op1 = toD(R1.Rows[0].Cells[1].Value.ToString());

long op2 = toD(R2.Rows[0].Cells[1].Value.ToString());

long op = op1 + op2;

if (op == 0)

Z.Checked = true;

BitArray ba = new BitArray(64);

toDD(ba, op);

string s = bitarrayout(ba);

R1.Rows[0].Cells[1].Value = s;

}

break;

}

case "adc":

{

long c = 0;

if (CC.Checked==true)

c = 1;

// дешифрация остальных операндов

opr();

// выполнение операции add

if (opcap == 8)

{

// определение регистров

int r1 = 8 - (int)toD(src1.ToString());

int r2 = 8 - (int)toD(src2.ToString());

long op1 = toD(RG0.Rows[0].Cells[r1].Value.ToString());

long op2 = toD(RG0.Rows[0].Cells[r2].Value.ToString());

long op = op1 + op2+c;

if (op == 0)

Z.Checked = true;

BitArray ba = new BitArray(8);

toDD(ba, op);

string s = bitarrayout(ba);

RG0.Rows[0].Cells[r1].Value = s;

}

if (opcap == 32)

{

int r1 = (int)toD(src1.ToString());

int r2 = (int)toD(src2.ToString());

if (r1 > 1)

{

R1 = RG2;

r1 = r1 - 2;

}

else

R1 = RG1;

if (r2 > 1)

{

R2 = RG2;

r2 = r2 - 2;

}

else

R2 = RG1;

long op1 = toD(R1.Rows[0].Cells[2 - r1].Value.ToString());

long op2 = toD(R2.Rows[0].Cells[2 - r2].Value.ToString());

long op = op1 + op2 + c;

if (op == 0)

Z.Checked = true;

BitArray ba = new BitArray(32);

toDD(ba, op);

string s = bitarrayout(ba);

R1.Rows[0].Cells[2 - r1].Value = s;

}

if (opcap == 64)

{

long r1 = toD(src1.ToString());

long r2 = toD(src2.ToString());

R1 = reg64(r1);

R2 = reg64(r2);

long op1 = toD(R1.Rows[0].Cells[1].Value.ToString());

long op2 = toD(R2.Rows[0].Cells[1].Value.ToString());

long op = op1 + op2 + c;

if (op == 0)

Z.Checked = true;

BitArray ba = new BitArray(64);

toDD(ba, op);

string s = bitarrayout(ba);

R1.Rows[0].Cells[1].Value = s;

}

break;

}

case "mul":

{

// дешифрация остальных операндов

opr();

// выполнение операции add

if (opcap == 8)

{

// определение регистров

int r1 = 8 - (int)toD(src1.ToString());

int r2 = 8 - (int)toD(src2.ToString());

long op1 = toD(RG0.Rows[0].Cells[r1].Value.ToString());

long op2 = toD(RG0.Rows[0].Cells[r2].Value.ToString());

long op = op1 * op2;

if (op == 0)

Z.Checked = true;

BitArray ba = new BitArray(8);

toDD(ba, op);

string s = bitarrayout(ba);

RG0.Rows[0].Cells[r1].Value = s;

}

if (opcap == 32)

{

int r1 = (int)toD(src1.ToString());

int r2 = (int)toD(src2.ToString());

if (r1 > 1)

{

R1 = RG2;

r1 = r1 - 2;

}

else

R1 = RG1;

if (r2 > 1)

{

R2 = RG2;

r2 = r2 - 2;

}

else

R2 = RG1;

long op1 = toD(R1.Rows[0].Cells[2 - r1].Value.ToString());

long op2 = toD(R2.Rows[0].Cells[2 - r2].Value.ToString());

long op = op1 * op2;

if (op == 0)

Z.Checked = true;

BitArray ba = new BitArray(32);

toDD(ba, op);

string s = bitarrayout(ba);

R1.Rows[0].Cells[2 - r1].Value = s;

}

if (opcap == 64)

{

long r1 = toD(src1.ToString());

long r2 = toD(src2.ToString());

R1 = reg64(r1);

R2 = reg64(r2);

long op1 = toD(R1.Rows[0].Cells[1].Value.ToString());

long op2 = toD(R2.Rows[0].Cells[1].Value.ToString());

long op = op1 * op2;

if (op == 0)

Z.Checked = true;

BitArray ba = new BitArray(64);

toDD(ba, op);

string s = bitarrayout(ba);

R1.Rows[0].Cells[1].Value = s;

}

break;

}

case "div":

{

// дешифрация остальных операндов

opr();

// выполнение операции add

if (opcap == 8)

{

// определение регистров

int r1 = 8 - (int)toD(src1.ToString());

int r2 = 8 - (int)toD(src2.ToString());

long op1 = toD(RG0.Rows[0].Cells[r1].Value.ToString());

long op2 = toD(RG0.Rows[0].Cells[r2].Value.ToString());

long op = op1 / op2;

if (op == 0)

Z.Checked = true;

BitArray ba = new BitArray(8);

toDD(ba, op);

string s = bitarrayout(ba);

RG0.Rows[0].Cells[r1].Value = s;

}

if (opcap == 32)

{

int r1 = (int)toD(src1.ToString());

int r2 = (int)toD(src2.ToString());

if (r1 > 1)

{

R1 = RG2;

r1 = r1 - 2;

}

else

R1 = RG1;

if (r2 > 1)

{

R2 = RG2;

r2 = r2 - 2;

}

else

R2 = RG1;

long op1 = toD(R1.Rows[0].Cells[2 - r1].Value.ToString());

long op2 = toD(R2.Rows[0].Cells[2 - r2].Value.ToString());

long op = op1 / op2;

if (op == 0)

Z.Checked = true;

BitArray ba = new BitArray(32);

toDD(ba, op);

string s = bitarrayout(ba);

R1.Rows[0].Cells[2 - r1].Value = s;

}

if (opcap == 64)

{

long r1 = toD(src1.ToString());

long r2 = toD(src2.ToString());

R1 = reg64(r1);

R2 = reg64(r2);

long op1 = toD(R1.Rows[0].Cells[1].Value.ToString());

long op2 = toD(R2.Rows[0].Cells[1].Value.ToString());

long op = op1 / op2;

if (op == 0)

Z.Checked = true;

BitArray ba = new BitArray(64);

toDD(ba, op);

string s = bitarrayout(ba);

R1.Rows[0].Cells[1].Value = s;

}

break;

}

case "cp":

{

// дешифрация остальных операндов

opr();

// выполнение операции add

if (opcap == 8)

{

// определение регистров

int r1 = 8 - (int)toD(src1.ToString());

int r2 = 8 - (int)toD(src2.ToString());

long op1 = toD(RG0.Rows[0].Cells[r1].Value.ToString());

long op2 = toD(RG0.Rows[0].Cells[r2].Value.ToString());

long op = op1 - op2;

if (op < 0)

S.Checked = true;

if (op == 0)

Z.Checked = true;

}

if (opcap == 32)

{

int r1 = (int)toD(src1.ToString());

int r2 = (int)toD(src2.ToString());

if (r1 > 1)

{

R1 = RG2;

r1 = r1 - 2;

}

else

R1 = RG1;

if (r2 > 1)

{

R2 = RG2;

r2 = r2 - 2;

}

else

R2 = RG1;

long op1 = toD(R1.Rows[0].Cells[2 - r1].Value.ToString());

long op2 = toD(R2.Rows[0].Cells[2 - r2].Value.ToString());

long op = op1 - op2;

if (op < 0)

S.Checked = true;

if (op == 0)

Z.Checked = true;

}

if (opcap == 64)

{

long r1 = toD(src1.ToString());

long r2 = toD(src2.ToString());

R1 = reg64(r1);

R2 = reg64(r2);

long op1 = toD(R1.Rows[0].Cells[1].Value.ToString());

long op2 = toD(R2.Rows[0].Cells[1].Value.ToString());

long op = op1 - op2;

if (op < 0)

S.Checked = true;

if (op == 0)

Z.Checked = true;

}

break;

}

case "sub":

{

// дешифрация остальных операндов

opr();

// выполнение операции add

if (opcap == 8)

{

// определение регистров

int r1 = 8 - (int)toD(src1.ToString());

int r2 = 8 - (int)toD(src2.ToString());

long op1 = toD(RG0.Rows[0].Cells[r1].Value.ToString());

long op2 = toD(RG0.Rows[0].Cells[r2].Value.ToString());

long op = op1 - op2;

if (op == 0)

Z.Checked = true;

BitArray ba = new BitArray(8);

toDD(ba, op);

string s = bitarrayout(ba);

RG0.Rows[0].Cells[r1].Value = s;

}

if (opcap == 32)

{

int r1 = (int)toD(src1.ToString());

int r2 = (int)toD(src2.ToString());

if (r1 > 1)

{

R1 = RG2;

r1 = r1 - 2;

}

else

R1 = RG1;

if (r2 > 1)

{

R2 = RG2;

r2 = r2 - 2;

}

else

R2 = RG1;

long op1 = toD(R1.Rows[0].Cells[2 - r1].Value.ToString());

long op2 = toD(R2.Rows[0].Cells[2 - r2].Value.ToString());

long op = op1 - op2;

if (op == 0)

Z.Checked = true;

BitArray ba = new BitArray(32);

toDD(ba, op);

string s = bitarrayout(ba);

R1.Rows[0].Cells[2 - r1].Value = s;

}

if (opcap == 64)

{

long r1 = toD(src1.ToString());

long r2 = toD(src2.ToString());

R1 = reg64(r1);

R2 = reg64(r2);

long op1 = toD(R1.Rows[0].Cells[1].Value.ToString());

long op2 = toD(R2.Rows[0].Cells[1].Value.ToString());

long op = op1 - op2;

if (op == 0)

Z.Checked = true;

BitArray ba = new BitArray(64);

toDD(ba, op);

string s = bitarrayout(ba);

R1.Rows[0].Cells[1].Value = s;

}

break;

}

case "sbc":

{

// дешифрация остальных операндов

opr();

// выполнение операции add

if (opcap == 8)

{

// определение регистров

int r1 = 8 - (int)toD(src1.ToString());

int r2 = 8 - (int)toD(src2.ToString());

long op1 = toD(RG0.Rows[0].Cells[r1].Value.ToString());

long op2 = toD(RG0.Rows[0].Cells[r2].Value.ToString());

long op = op1 - op2;

BitArray ba = new BitArray(8);

toDD(ba, op);

string s = bitarrayout(ba);

RG0.Rows[0].Cells[r1].Value = s;

}

if (opcap == 32)

{

int r1 = (int)toD(src1.ToString());

int r2 = (int)toD(src2.ToString());

if (r1 > 1)

{

R1 = RG2;

r1 = r1 - 2;

}

else

R1 = RG1;

if (r2 > 1)

{

R2 = RG2;

r2 = r2 - 2;

}

else

R2 = RG1;

long op1 = toD(R1.Rows[0].Cells[2 - r1].Value.ToString());

long op2 = toD(R2.Rows[0].Cells[2 - r2].Value.ToString());

long op = op1 - op2;

BitArray ba = new BitArray(32);

toDD(ba, op);

string s = bitarrayout(ba);

R1.Rows[0].Cells[2 - r1].Value = s;

}

if (opcap == 64)

{

long r1 = toD(src1.ToString());

long r2 = toD(src2.ToString());

R1 = reg64(r1);

R2 = reg64(r2);

long op1 = toD(R1.Rows[0].Cells[1].Value.ToString());

long op2 = toD(R2.Rows[0].Cells[1].Value.ToString());

long op = op1 - op2;

BitArray ba = new BitArray(64);

toDD(ba, op);

string s = bitarrayout(ba);

R1.Rows[0].Cells[1].Value = s;

}

break;

}

case "and":

{

// дешифрация остальных операндов

opr();

// выполнение операции add

if (opcap == 8)

{

// определение регистров

int r1 = 8 - (int)toD(src1.ToString());

int r2 = 8 - (int)toD(src2.ToString());

long op1 = toD(RG0.Rows[0].Cells[r1].Value.ToString());

long op2 = toD(RG0.Rows[0].Cells[r2].Value.ToString());

BitArray ba1 = new BitArray(8);

BitArray ba2 = new BitArray(8);

toDD(ba1, op1);

toDD(ba2, op2);

ba1.And(ba2);

string s = bitarrayout(ba1);

RG0.Rows[0].Cells[r1].Value = s;

}

if (opcap == 32)

{

int r1 = (int)toD(src1.ToString());

int r2 = (int)toD(src2.ToString());

if (r1 > 1)

{

R1 = RG2;

r1 = r1 - 2;

}

else

R1 = RG1;

if (r2 > 1)

{

R2 = RG2;

r2 = r2 - 2;

}

else

R2 = RG1;

long op1 = toD(R1.Rows[0].Cells[2 - r1].Value.ToString());

long op2 = toD(R2.Rows[0].Cells[2 - r2].Value.ToString());

BitArray ba1 = new BitArray(32);

BitArray ba2 = new BitArray(32);

toDD(ba1, op1);

toDD(ba2, op2);

ba1.And(ba2);

string s = bitarrayout(ba1);

R1.Rows[0].Cells[2 - r1].Value = s;

}

if (opcap == 64)

{

long r1 = toD(src1.ToString());

long r2 = toD(src2.ToString());

R1 = reg64(r1);

R2 = reg64(r2);

long op1 = toD(R1.Rows[0].Cells[1].Value.ToString());

long op2 = toD(R2.Rows[0].Cells[1].Value.ToString());

BitArray ba1 = new BitArray(64);

BitArray ba2 = new BitArray(64);

toDD(ba1, op1);

toDD(ba2, op2);

ba1.And(ba2);

string s = bitarrayout(ba1);

R1.Rows[0].Cells[1].Value = s;

}

break;

}

case "or":

{

// дешифрация остальных операндов

opr();

// выполнение операции add

if (opcap == 8)

{

// определение регистров

int r1 = 8 - (int)toD(src1.ToString());

int r2 = 8 - (int)toD(src2.ToString());

long op1 = toD(RG0.Rows[0].Cells[r1].Value.ToString());

long op2 = toD(RG0.Rows[0].Cells[r2].Value.ToString());

BitArray ba1 = new BitArray(8);

BitArray ba2 = new BitArray(8);

toDD(ba1, op1);

toDD(ba2, op2);

ba1.Or(ba2);

string s = bitarrayout(ba1);

RG0.Rows[0].Cells[r1].Value = s;

}

if (opcap == 32)

{

int r1 = (int)toD(src1.ToString());

int r2 = (int)toD(src2.ToString());

if (r1 > 1)

{

R1 = RG2;

r1 = r1 - 2;

}

else

R1 = RG1;

if (r2 > 1)

{

R2 = RG2;

r2 = r2 - 2;

}

else

R2 = RG1;

long op1 = toD(R1.Rows[0].Cells[2 - r1].Value.ToString());

long op2 = toD(R2.Rows[0].Cells[2 - r2].Value.ToString());

BitArray ba1 = new BitArray(32);

BitArray ba2 = new BitArray(32);

toDD(ba1, op1);

toDD(ba2, op2);

ba1.Or(ba2);

string s = bitarrayout(ba1);

R1.Rows[0].Cells[2 - r1].Value = s;

}

if (opcap == 64)

{

long r1 = toD(src1.ToString());

long r2 = toD(src2.ToString());

R1 = reg64(r1);

R2 = reg64(r2);

long op1 = toD(R1.Rows[0].Cells[1].Value.ToString());

long op2 = toD(R2.Rows[0].Cells[1].Value.ToString());

BitArray ba1 = new BitArray(64);

BitArray ba2 = new BitArray(64);

toDD(ba1, op1);

toDD(ba2, op2);

ba1.Or(ba2);

string s = bitarrayout(ba1);

R1.Rows[0].Cells[1].Value = s;

}

break;

}

case "xor":

{

// дешифрация остальных операндов

opr();

// выполнение операции add

if (opcap == 8)

{

// определение регистров

int r1 = 8 - (int)toD(src1.ToString());

int r2 = 8 - (int)toD(src2.ToString());

long op1 = toD(RG0.Rows[0].Cells[r1].Value.ToString());

long op2 = toD(RG0.Rows[0].Cells[r2].Value.ToString());

BitArray ba1 = new BitArray(8);

BitArray ba2 = new BitArray(8);

toDD(ba1, op1);

toDD(ba2, op2);

ba1.Xor(ba2);

string s = bitarrayout(ba1);

RG0.Rows[0].Cells[r1].Value = s;

}

if (opcap == 32)

{

int r1 = (int)toD(src1.ToString());

int r2 = (int)toD(src2.ToString());

if (r1 > 1)

{

R1 = RG2;

r1 = r1 - 2;

}

else

R1 = RG1;

if (r2 > 1)

{

R2 = RG2;

r2 = r2 - 2;

}

else

R2 = RG1;

long op1 = toD(R1.Rows[0].Cells[2 - r1].Value.ToString());

long op2 = toD(R2.Rows[0].Cells[2 - r2].Value.ToString());

BitArray ba1 = new BitArray(32);

BitArray ba2 = new BitArray(32);

toDD(ba1, op1);

toDD(ba2, op2);

ba1.Xor(ba2);

string s = bitarrayout(ba1);

R1.Rows[0].Cells[2 - r1].Value = s;

}

if (opcap == 64)

{

long r1 = toD(src1.ToString());

long r2 = toD(src2.ToString());

R1 = reg64(r1);

R2 = reg64(r2);

long op1 = toD(R1.Rows[0].Cells[1].Value.ToString());

long op2 = toD(R2.Rows[0].Cells[1].Value.ToString());

BitArray ba1 = new BitArray(64);

BitArray ba2 = new BitArray(64);

toDD(ba1, op1);

toDD(ba2, op2);

ba1.Xor(ba2);

string s = bitarrayout(ba1);

R1.Rows[0].Cells[1].Value = s;

}

break;

}

case "cpl":

{

opr();

if (opcap == 8)

{

// определение регистров

int r1 = 8 - (int)toD(src1.ToString());

long op1 = toD(RG0.Rows[0].Cells[r1].Value.ToString());

BitArray ba1 = new BitArray(8);

ba1.Not();

string s = bitarrayout(ba1);

RG0.Rows[0].Cells[r1].Value = s;

}

if (opcap == 32)

{

int r1 = (int)toD(src1.ToString());

if (r1 > 1)

{

R1 = RG2;

r1 = r1 - 2;

}

else

R1 = RG1;

long op1 = toD(R1.Rows[0].Cells[2 - r1].Value.ToString());

BitArray ba1 = new BitArray(32);

ba1.Not();

string s = bitarrayout(ba1);

R1.Rows[0].Cells[2 - r1].Value = s;

}

if (opcap == 64)

{

long r1 = toD(src1.ToString());

R1 = reg64(r1);

long op1 = toD(R1.Rows[0].Cells[1].Value.ToString());

BitArray ba1 = new BitArray(64);

ba1.Not();

string s = bitarrayout(ba1);

R1.Rows[0].Cells[1].Value = s;

}

break;

}

case "lddw":

{

opr();

if (opcap == 64)

{

src2 = src2 - 100;

long r2 = toD(src2.ToString());

R1 = reg64(r2);

//адрес в десятичном виде

long op1 = toD(RG7.Rows[0].Cells[1].Value.ToString());

int i;

for (i = 0; i < dataGridViewOP.RowCount; i++)

{

if(dataGridViewOP.Rows[i].Cells[0].Value.ToString()==op1.ToString())

break;

}

R1.Rows[0].Cells[1].Value = dataGridViewOP.Rows[i].Cells[1].Value.ToString();

}

break;

}

case "ldw":

{

opr();

if (opcap == 32)

{

int r1 = (int)toD(src2.ToString());

if (r1 > 1)

{

R1 = RG2;

r1 = r1 - 2;

}

else

R1 = RG1;

//адрес в десятичном виде

long op1 = toD(RG7.Rows[0].Cells[1].Value.ToString());

int i;

for (i = 0; i < dataGridViewOP.RowCount; i++)

{

if (dataGridViewOP.Rows[i].Cells[0].Value.ToString() == op1.ToString())

break;

}

string s = dataGridViewOP.Rows[i].Cells[1].Value.ToString();

string str = s.Substring(32);

R1.Rows[0].Cells[2-r1].Value = str;

}

break;

}

case "ldb":

{

opr();

if (opcap == 8)

{

// определение регистров

int r1 = 8 - (int)toD(src2.ToString());

//адрес в десятичном виде

long op1 = toD(RG7.Rows[0].Cells[1].Value.ToString());

int i;

try

{

for (i = 0; i < dataGridViewOP.RowCount - 1; i++)

{

if (dataGridViewOP.Rows[i].Cells[0].Value.ToString() == op1.ToString())

break;

}

string s = dataGridViewOP.Rows[i].Cells[1].Value.ToString();

string str = s.Substring(56);

RG0.Rows[0].Cells[r1].Value = str;

}

catch (Exception)

{

MessageBox.Show("memory Error!");

}

}

break;

}

case "jz":

{

if (Z.Checked == true)

{

// переход к команде кторая записана в регистре

int dest = 8 - (int)toD(cap.ToString());

int r1 = 8 - (int)toD(src1.ToString()); // номер регистра

int r2 = (int)toD(src2.ToString()); //смещение

long op1 = toD(RG0.Rows[0].Cells[r1].Value.ToString());

com = (int)op1+r2;

labelPC1.Text = com.ToString();

}

break;

}

case "jnz":

{

if (Z.Checked == false)

{

// переход к команде кторая записана в регистре

int dest = 8 - (int)toD(cap.ToString());

int r1 = 8 - (int)toD(src1.ToString()); // номер регистра

int r2 = (int)toD(src2.ToString()); //смещение

long op1 = toD(RG0.Rows[0].Cells[r1].Value.ToString());

com = (int)op1 + r2;

labelPC1.Text = com.ToString();

}

break;

}

case "stdw":

{

if (opcap == 64)

{

// определение регистров

src2 = src2 - 100;

long r2 = toD(src2.ToString());

R1 = reg64(r2);

//адрес в десятичном виде

long op1 = toD(RG7.Rows[0].Cells[1].Value.ToString());

int i;

try

{

for (i = 0; i < dataGridViewOP.RowCount - 1; i++)

{

if (dataGridViewOP.Rows[i].Cells[0].Value.ToString() == op1.ToString())

dataGridViewOP.Rows[i].Cells[1].Value = R1.Rows[0].Cells[1].Value.ToString();

}

}

catch (Exception)

{

MessageBox.Show("memory Error!");

}

}

break;

}

default:

{

MessageBox.Show("command error");

break;

}

}

}

private void buttonCmd_Click(object sender, EventArgs e)

{

int c=Cmd.RowCount-1;

com = 0;

bool b=true;

while (b)

{

rows = Cmd.Rows[com];

Program();

c--;

try

{

for (int i = 0; i < Cmd.RowCount; i++)

{

if (Cmd.Rows[i].Cells[0].Value.ToString() == (com * 4).ToString())

{

b = true;

break;

}

else

b = false;

}

}

catch (Exception)

{

b=false;

break;

}

if (MessageBox.Show("Продолжить выполнение", "info", MessageBoxButtons.YesNo) != DialogResult.Yes)

break;

}

labelPC1.Text = "0";

}

private void labelPC1_Click(object sender, EventArgs e)

{

}

}

}