Разработка эмулятора

Размещено на http://www.allbest.ru/

Введение

Задачами курсового проектирования по дисциплине «Программирование» являются:

* развитие умения разрабатывать программные модели средней сложности,

* развитие навыков выполнения научно-исследовательских работ в области разработки и стыковки многомодульных программных комплексов;

* развитие навыков работы со стандартами, научно-технической и справочной литературой в области программирования и вычислительной техники; [1, c. 4]

В настоящее время, не смотря на изобилие различного рода языков высокого уровня, все еще находят применение языки ассемблера. В отличие от высокоуровневых языков, где оператору сопоставлено множество машинных кодов, в ассемблерах существует однозначное соответствие между командой и машинным кодом. В этом заключается преимущество низкоуровневых языков программирования. Создавая программу на ассемблере, не обязательно использовать многие модули и дополнительные операции, которые добавляются автоматически в высокоуровневых программах. Это приводит как к уменьшению длины кода, так и к увеличению ее быстродействия. Кроме того, существует возможность решения обратной задачи: перевода машинного кода в программу. Обычно вместе с ассемблерами разрабатываются отладчики. Отладчик позволяет проследить за выполнением программы, вычислительными ресурсами и, при необходимости найти ошибку в коде, либо разобраться в особенностях работы программы на данной ЭВМ.

Данный курсовой проект состоит в разработке пакета программ из ассемблера, отладчика и интерфейса, использующих некоторую систему команд. Конечно, программы не смогут реализовывать всех возможностей современной ЭВМ, но позволят выработать навыки в области алгоритмизации и программирования.

Объем оперативной памяти 2048 байт (8 стр. по 256 байт). Разрядность памяти 11 бит.

Так как работа эмулятора является циклической (за каждый цикл обрабатывается одна команда), то рассмотрим работу процессора за один цикл. Вначале команда выбирается из памяти по адресу, хранящемуся в СЧАК, ее байты заносятся в РК. Затем УУ обрабатывает код команды, заполняет регистры Р1, Р2, А1, А2 и посылает сигналы управления в АЛУ. АЛУ, считая, что операнды для операции расположены в регистрах Р1 и Р2, получает результат и размещает его в регистре А3. Для результата формируются биты признаков (условий) и помещаются в регистр РФ. Затем СЧАК увеличивается на длину команды, либо изменяется искусственно.

1. Постановка задачи

В ходе курсового проекта необходимо разработать программу эмулятора, которая должна имитировать рабочий цикл процессора для каждой команды. При выполнении цикла из памяти читается код команды, адрес которой хранится в счетчике адреса команд (СЧАК). Затем по коду команды определяется количество байтов кода, принадлежащих этой команде, количество и расположение операндов. Процессор читает из памяти операнды исходных данных и выполняет операцию, формирует признаки результата, фиксируя их в регистре флагов (РФ). Далее значение СЧАК увеличивается на длину команды и цикл повторяется сначала, до тех пор, пока не будет обнаружен признак конца команд.

Структура эмулятора должна содержать основные элементы любого процессора: оперативную память, устройство управления (УУ), арифметико-логическое устройство.

Эмулятору необходимо создать массив памяти, который будет заполнен кодами команд и переменными. Каждый элемент массива соответствует ячейке памяти, используемой при выполнении команд. После заполнения памяти отладчик должен выполнить заданные команды, если они будут найдены в таблице команд, представленной ассемблером.

Исходными данными является объектный файл, полученный в результате работы ассемблера. В итоге, отладчик выдает как результат массив памяти и файл протокола, для каждой команды содержащий значения регистров, СЧАК, адрес и значение измененных ячеек памяти. Результатом будет текстовый файл «Result.txt».

2. Анализ структуры микропроцессора

Дана следующая структура процессора (структура 5).



В состав процессора входят:

· Арифметико-логическое устройство (АЛУ)

· Регистры АЛУ: регистры операндов Р1 и Р2, регистр флагов (Флаги)

· Регистры общего назначения: адресные регистры АДРЕС1 (A1) и АДРЕС2 (A2) содержат адреса операндов команд, АДРЕС3 (A3) - адрес результата операции. Эти регистры определяют смещение в диапазоне 0-255 внутри страницы.

· Счетчик адреса команд (СЧАК)

· Регистр команд (РК)

· Шина адреса, шина данных

В состав оперативной памяти входят:

· Адрес оперативной памяти (АОП)

· Регистр оперативной памяти (РОП)

· Собственно ячейки памяти

Объем оперативной памяти 2048 байт (8 стр. по 256 байт). Разрядность памяти имеет 12 битов, но старший бит не используется.

Так как работа эмулятора является циклической (за каждый цикл обрабатывается одна команда), то рассмотрим работу процессора за один цикл. Вначале команда выбирается из памяти по адресу, хранящемуся в СЧАК, ее байты заносятся в РК. Затем УУ обрабатывает данные о команде, заполняет регистры и подает информацию в АЛУ, о необходимости выполнения операции. АЛУ выполняет операцию, результат помещает в память по адресу А3, формирует РФ. Затем СЧАК увеличивается на длину команды, либо изменяется искусственно.

3. Моделирующие переменные

Так как моделируемая ЭВМ содержит три основных устройства: память, УУ, АЛУ-то программа тоже будет содержать три класса. Распишем все моделирующие переменные по классам.

В класс RAM (класс, обозначающий память) будут входить РОП, АОП и собственно память. Оперативную память представим одномерным массивом байтов. Так как заданный объем оперативной памяти 2048 байт, то и размер массива тоже будет 2048. Каждому элементу массива при этом соответствует ячейка памяти, то есть один байт. Уровень доступа ограничим, так как в реальном процессоре мы не можем изменять значения ячеек памяти напрямую.

АОП хранит информацию об адресе ячейки из которой (в которую) читаются (записываются) данные. Так как память состоит из 8 строк в диапазоне 0-255 байт, то АОП будем представлять двухбайтовой переменной (тип short), которая будет содержать номер элемента массива.

РОП хранит данные, содержащиеся в ячейке, из которой читают или записывают данные. Так как в памяти хранятся байты, то и РОП будет иметь тип byte.

В класс ALU будут входить регистры Р1, Р2, Флаги, А1, А2, А3.

Р1 и Р2 - регистры операндов, а значит их тип будет byte.

Адресные регистры указывают на смещение в странице, значит они имеют значения от 0 до 255, для обозначения этого используем тип byte. Создадим массив состоящий из трех элементов (public byte [] A=new byte[3];). A[0] - регистр A1, A[1] - регистр A2, A[2] - регистр A3. Это позволит уменьшить описание команд MOVAi, так как по коду команды будет видно в какой из регистров записать константу.

Регистр флагов обозначим переменной RF типа byte. Данная переменная формирует три признака. Для описания этого понадобится три бита.

1-й бит отвечает за равенство результата нулю, 2-ой - за отрицательность результата, 3-ий за арифметическое переполнение. Если результат имеет какой-либо признак, то в этом бите находиться 1, иначе 0.

В класс UU (устройства управления) будут входить СЧАК и РК.

СЧАК представим переменной типа short, так как адрес в массиве памяти задается от 0 до 2047. public short SCHAK=0;

Для регистра команд создадим массив из двух элементов, так как команды могут быть длиной в 1 или 2 байта. В первой ячейке будет храниться первый байт команды, во второй ячейке - второй байт команды.

4. Анализ набора команд

Мнемоника команд моделируемого процессора

Код	Мнемокод	Описание
00000	MOVA1 константа	А1=константа
00001	MOVA2 константа	А2=константа
00010	MOVA3 константа	А3=константа
00100	ADD страница*	Память[А3]= Память[А1]+ Память[А2]
00101	ADС страница	Память[А3]= Память[А1]+ Память[А2]+флаг переп.
00110	SUB страница	Память[А3]= Память[А1] - Память[А2]
00111	SBB страница	Память[А3]= Память[А1] - Память[АС2] - флаг переп.
01000	MUL страница	Память[А3]= Память[А1]* Память[А2]
01001	DIV страница	Память[А3]= Память[А1]/ Память[А2]
01010	MOD страница	Память[А3]= Память[А1]% Память[А2]
01011	ABS страница	Память[А3]= | Память[А1] |
01100	AND страница	Память[А3]=Память[А1]& Память[А2]
01101	OR страница	Память[А3]= Память[А1] | Память[А2]
01110	XOR страница	Память[А3]= Память[А1] ^ Память[А2]
01111	NOT страница	Память[А3]=not Память[А1]
10000	JMP страница	Переход по адресу А3
10001	JB страница	Переход по адресу А3, если результат меньше 0
10010	JNZ страница	Переход по адресу А3, если результат не равен 0
10101	MOVS	Память[А3]=Память[А1], А3+=1, А1+=1
10101	CMPS	Сравнение данных Память[А1] и Память[А3]

Команды имеют длину один или два байта. Биты 0-4 первого байта определяют код команды в соответствии с таблицей команд. Биты 5-7 первого байта задают номер страницы ОП, в которой располагаются данные. Второй байт определяет константу.

Как видно из таблицы команд, все команды делятся на 3 типа:

1. Команды длиной 1 байт, код + №страницы (показаны желтым и зеленым цветом). Эти команды разобьем на еще на два подтипа

· Команды первого подтипа (зеленый цвет) выполняют арифметическую или логическую операцию. При прочтении команды этого типа из памяти по адресу, хранящемуся в регистрах А1 и А2, данные копируются в регистры АЛУ Р1 и Р2. Затем выполняется операция и полученный результат записывается в ячейку памяти с номером, хранящимся в А3. После этого устанавливаются регистры флагов и СЧАК увеличивается на 1.

· Команды второго подтипа (желтый цвет). Эти команды не выполняют ни каких операций, они отвечают за переход по адресу А3. При этом СЧАК принимает значение А3, установка флагов не требуется.

2. Команды длиной 1 байт, код + 000 (показаны светло-синим цветом)

Эти команды заполняют регистры Р1 и Р2 значениями, содержащимися в А1 и А2. Они также не требуют установки флагов. После их выполнения СЧАК увеличивается на 1.

3. Команды длиной 2 байта, код+000 константа (показаны красным цветом).

Эти команды заполняют адресные регистры А1, А2, А3, записывая в них константу, хранящуюся во втором байте. После выполнения этих команд СЧАК увеличивается на 2.

эмулятор программа процессор цикл

5. Разработка структуры программы: классов и методов

При преобразовании команд из мнемокода ассемблер использует формат «признак-байт». Тогда в каждой паре байтов первый байт может принимать значения: 0 - признак того, что второй байт пары адрес размещения следующих байтов программы, 1-признак того, что второй байт пары - командный байт.

помещает команду, хранящуюся в ячейке памяти под номером, записанным в SCHAK, в нулевой элемент массива RК, с помощью switch определяет по коду команду, каков ее размер, и записывает второй байт команды, для команд второго типа, в первый элемент массива. После этого для команд второго типа заполняются адресные регистры, для команд типа 1А - регистры R1 и R2, затем вызывается соответствующий метод ALU. По окончании метода для команд типа 1А переменная класса RAM memChange получит значение true, для того, чтобы затем знать об изменении в памяти. SCHAK увеличивается на длину команды. Кроме команд указанных в мнемонике данной структуры UU определяет условную команду HALT. Для этой команды не выполняется никаких действий, лишь значение isRunning изменяется на false. После этого данные о регистрах выводятся в файл протокола.

Класс processor будет управлять выполнением программы.

Он будет содержать экземпляры классов RAM, UU, ALU.

В этом классе будет содержаться метод чтения из объектного файла и заполнения памяти, метод обнуления памяти и всех регистров, метод вывода массива памяти, методы для пошагового и полного выполнения программы.

Метод input (чтение) не содержит параметров и возвращаемого значения. Метод будет работать с потоком ввода. Так как входной файл бинарный, то необходимо использовать класс RandomAccessFile. Из исходного файла данные будем посимвольно считывать и записывать в байтовый массив VXfile. Затем, используя этот массив, будем заполнять память. В цикле for от начала до конца VXfile, используя переключатель switch, будем сравнивать значение элемента массива с 0 или 1. Так как использовался формат «признак-байт», то если VХfile[i] будет равно 0, то Vxfile [i+1] и VXfile [i+3] будут являться адресом размещения следующих команд (страница и смещение соответственно). Если же VХfile[i]=1, то следующий байт является командным и будет записан с помощью метода write() класса RAM в память.

Метод makingNull (обнуление памяти) не содержит параметров и возвращаемого значения. Этот метод необходим для обнуления массива памяти и регистров перед выполнением, для наглядности.

Метод out (вывод массива памяти) не содержит параметров и возвращаемого значения. Он работает с потоком вывода в тестовый файл. В цикле for для АОП от 0 до 2047 в файл Result.txt выводится значение РОП. Затем поток вывода закрывается.

Метод makeAll (выполнение всех команд) не содержит параметров и возвращаемого значения. В теле метода будем использовать цикл while. Пока переменная isRunning класса UU имеет значение true, будем выполнять метод steps класса UU.

Метод makeOne (выполнение всех команд) не содержит параметров и возвращаемого значения. В теле метода будем использовать условие, если переменная isRunning класса UU имеет значение true будем выполнять метод steps класса UU.

6. Тестовый пример

Тестовый пример:

Исходный текст программы:

ORG 00H, 00H,

MOVA3 05H

JMP 01H

ORG 01H, 05H

MOVA1 0CH

MOVA3 0DH

NOT 01H

HALT

ORG 01H, 0CH

DB 01H

Текст программы, переведенный в код «признак-байт»:

00 00 00 00 01 10 01 05 01 81 00 01 00 05 01 00 01 0с 01 01 10 0d 79 01 ff 00 01 00 0с 01 01

Выходные данные отладчика:

16 5 -127 0 0 0 0 0 0 0 0 0 0 0 0 0… 0 0 0 0

0 0 0 0 0 0 12 16 13 121 -1 0 1 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

Выполнена команда MOVA3 5

А1 0

А2 0

А3 5

Р1 0

Р2 0

РФ 0

СЧАК 2

Выполнена команда JMP 1

А1 0

А2 0

А3 5

Р1 0

Р2 0

РФ 0

СЧАК 105

Выполнена команда MOVA1 c

А1 c

А2 0

А3 5

Р1 0

Р2 0

РФ 0

СЧАК 107

Выполнена команда MOVA3 d

А1 c

А2 0

А3 d

Р1 0

Р2 0

РФ 0

СЧАК 109

Выполнена команда NOT 1

А1 c

А2 0

А3 d

Р1 1

Р2 0

РФ 6

СЧАК 10a

Записанo АОП = 10d

РОП = fe

Выполнена команда HALT

16 5 -127 0 0 0 0 0 0 0 0 0 0 0 0 0… 0 0 0 0

0 0 0 0 0 0 12 16 13 121 -1 0 1 -2 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

Заключение

В ходе выполнения курсовой работы создана программная модель кросс-отладчика. Данная программа имитирующую рабочий цикл процессора и выводит данные о пошаговом выполнении команд. Для наглядности, а также для связи с интерфейсом, программа выводит результаты выполнения команд в отдельный файл. Благодаря чему, можно детально рассмотреть рабочий цикл процессора. Данная работа помогает понять, как же работает микропроцессор, какие операции выполняет, какими командами на него влияют, что происходит под влиянием этих команд. А также не только улучшить навыки программирования, но и применять всевозможные алгоритмы.

Библиографический список

1. П. Ноутон, Г. Шилдт Java 2: The Complete Reference. - Издательство «БХВ-Петербург», 2007, 1072 с. Jennifer Golden, Java Programming Language, 2002

2. N. Cravotta «Real-time operating systems», Embedded system programming, 1997/march

Приложение

public class RAM {

private static byte[] R=new byte[2048];

public static short AOP=0;

public static byte ROP=0;

public static boolean memChange;

public void read() {

ROP=R[AOP];

}

public void write() {

R[AOP]=ROP;

}

}

public class ALU {

public byte R1=0;

public byte R2=0;

public byte RF=0;

public byte [] A=new byte[3];

public byte rez=0;

public RAM ram=new RAM();

 // public ALU() {

 // byte R1=0;

 // byte R2=0;

 // byte RF=0;}

public short address (byte p, byte s) {

short ad=0;

ad=(short) (p*256+s);

return ad;}

public void setFlags (int s)

{RF=0;

if (s==0) RF|=1; else RF&=(byte) 0xFE;

if (s<0) RF|=2; else RF&=(byte) 0xFD;

if((s>127)||(s<-128)) RF|=4; else RF&=(byte) 0xFB;

}

public void doADD (byte page) {

ram.AOP=address (page, A[2]);

ram.ROP=(byte) (R1+R2);

ram.write();

setFlags (R1+R2);

}

public void doADC (byte page) {

ram.AOP=address (page, A[2]);

setFlags (R1+R2);

ram.ROP=(byte) (R1+R2+RF&0x04);

ram.write();

}

public void doSUB (byte page) {

ram.AOP=address (page, A[2]);

ram.ROP=(byte) (R1-R2);

ram.write();

setFlags (R1-R2);

}

public void doSBB (byte page) {

ram.AOP=address (page, A[2]);

setFlags (R1-R2);

ram.ROP=(byte) (R1-R2-RF&0x04);

ram.write();

}

public void doMUL (byte page) {

ram.AOP=address (page, A[2]);

ram.ROP=(byte) (R1*R2);

ram.write();

setFlags (R1*R2);

}

public void doDIV (byte page) {

ram.AOP=address (page, A[2]);

ram.ROP=(byte) (R1/R2);

ram.write();

setFlags (R1/R2);

}

public void doMOD (byte page) {

ram.AOP=address (page, A[2]);

ram.ROP=(byte) (R1% R2);

ram.write();

setFlags (R1% R2);

}

public void doABS (byte page) {

ram.AOP=address (page, A[2]);

ram.ROP=(byte) ((R1|0xfe)&0x7f);

ram.write();

setFlags (java.lang. Math.abs(R1));

}

public void doAND (byte page) {

ram.AOP=address (page, A[2]);

ram.ROP=(byte) (R1&R2);

ram.write();

setFlags (R1&R2);

}

public void doOR (byte page) {

ram.AOP=address (page, A[2]);

ram.ROP=(byte) (R1|R2);

ram.write();

setFlags (R1|R2);

}

public void doXOR (byte page) {

ram.AOP=address (page, A[2]);

ram.ROP=(byte) (R1^R2);

ram.write();

setFlags (R1^R2);

}

public void doNOT (byte page) {

ram.AOP=address (page, A[2]);

ram.ROP=(byte) (~R1|0x01);

ram.write();

setFlags(~R1);

}

public void doMOVS (byte page) {

ram.AOP=address (page, A[2]);

ram.ROP=R1;

ram.write();

}

public void doCMPS() {

setFlags (R1-R2);

}

}

import java.io.*;

import java.lang.*;

import java.lang. Byte.*;

import java.lang. String.*;

public class UU {

public short SCHAK=0;

public byte[] RK=new byte[2];

public RAM ram=new RAM();

public ALU alu=new ALU();

public boolean isRunning=true;

PrintWriter out;

public void steps() throws IOException {

 // FileWriter out=new FileWriter («Result.txt», true);

out=new PrintWriter («Result.txt»);

String name=null;

int j=0;

byte page=0;

try {ram.AOP=SCHAK;

ram.read();

RK[0]=(byte) (ram.ROP);

page=(byte) (RK[0]&0x07);

switch((RK[0]&0xff)>>>3) {

case 0x00:

case 0x01:

case 0x02: {name= «MOVA»+((RK[0]>>>3)+1)+»»;

ram.AOP=(short) (SCHAK+1);

ram.read();

byte f=ram.ROP;

RK[1]=ram.ROP;

name+=Integer.toHexString (RK[1]);

alu.A [RK[0]>>>3]=RK[1];

ram.memChange=false;

SCHAK+=2;

break;}

case 0x04: {

name= «ADD»+» «+Integer.toHexString(page);

ram.AOP=alu.address (page, alu.A[0]);

ram.read();

alu.R1=ram.ROP;

ram.AOP=alu.address (page, alu.A[1]);

ram.read();

alu.R2=ram.ROP;

alu.doADD(page);

SCHAK+=1;

ram.memChange=true;

break;}

case 0x05: {

name= «ADC»+» «+Integer.toHexString(page);

ram.AOP=alu.address (page, alu.A[0]);

ram.read();

alu.R1=ram.ROP;

ram.AOP=alu.address (page, alu.A[1]);

ram.read();

alu.R2=ram.ROP;

alu.doADC(page);

SCHAK++;

ram.memChange=true;

break;}

case 0x06: {

name= «SUB»+» «+Integer.toHexString(page);

ram.AOP=alu.address (page, alu.A[0]);

ram.read();

alu.R1=ram.ROP;

ram.AOP=alu.address (page, alu.A[1]);

ram.read();

alu.R2=ram.ROP;

alu.doSUB(page);

SCHAK++;

ram.memChange=true;

break;}

case 0x07: {

name= «SBB»+» «+Integer.toHexString(page);

ram.AOP=alu.address (page, alu.A[0]);

ram.read();

alu.R1=ram.ROP;

ram.AOP=alu.address (page, alu.A[1]);

ram.read();

alu.R2=ram.ROP;

alu.doSBB(page);

SCHAK++;

ram.memChange=true;

break;}

case 0x08: {

name= «MUL»+» «+Integer.toHexString(page);

ram.AOP=alu.address (page, alu.A[0]);

ram.read();

alu.R1=ram.ROP;

ram.AOP=alu.address (page, alu.A[1]);

ram.read();

alu.R2=ram.ROP;

alu.doMUL(page);

SCHAK++;

ram.memChange=true;

break;}

case 0x09: {

name= «DIV»+» «+Integer.toHexString(page);

ram.AOP=alu.address (page, alu.A[0]);

ram.read();

alu.R1=ram.ROP;

ram.AOP=alu.address (page, alu.A[1]);

ram.read();

alu.R2=ram.ROP;

alu.doDIV(page);

SCHAK++;

ram.memChange=true;

break;}

case 0x0a: {

name= «MOD»+» «+Integer.toHexString(page);

ram.AOP=alu.address (page, alu.A[0]);

ram.read();

alu.R1=ram.ROP;

ram.AOP=alu.address (page, alu.A[1]);

ram.read();

alu.R2=ram.ROP;

alu.doMOD(page);

SCHAK++;

ram.memChange=true;

break;}

case 0x0b: {

name= «ABS»+» «+Integer.toHexString(page);

ram.AOP=alu.address (page, alu.A[0]);

ram.read();

alu.R1=ram.ROP;

ram.AOP=alu.address (page, alu.A[1]);

ram.read();

alu.R2=ram.ROP;

alu.doABS(page);

SCHAK++;

ram.memChange=true;

break;}

case 0x0c: {

name= «AND»+» «+Integer.toHexString(page);

ram.AOP=alu.address (page, alu.A[0]);

ram.read();

alu.R1=ram.ROP;

ram.AOP=alu.address (page, alu.A[1]);

ram.read();

alu.R2=ram.ROP;

alu.doAND(page);

SCHAK++;

ram.memChange=true;

break;}

case 0x0d: {

name= «OR»+» «+Integer.toHexString(page);

ram.AOP=alu.address (page, alu.A[0]);

ram.read();

alu.R1=ram.ROP;

ram.AOP=alu.address (page, alu.A[1]);

ram.read();

alu.R2=ram.ROP;

alu.doOR(page);

SCHAK++;

ram.memChange=true;

break;}

case 0x0e: {

name= «XOR»+» «+Integer.toHexString(page);

ram.AOP=alu.address (page, alu.A[0]);

ram.read();

alu.R1=ram.ROP;

ram.AOP=alu.address (page, alu.A[1]);

ram.read();

alu.R2=ram.ROP;

alu.doXOR(page);

SCHAK++;

ram.memChange=true;

break;}

case 0x0f: {

name= «NOT»+» «+Integer.toHexString(page);

ram.AOP=alu.address (page, alu.A[0]);

ram.read();

alu.R1=ram.ROP;

ram.AOP=alu.address (page, alu.A[1]);

ram.read();

alu.R2=ram.ROP;

alu.doNOT(page);

SCHAK++;

ram.memChange=true;

break;}

case 0x10: {

name= «JMP»+» «+Integer.toHexString(page);

ram.memChange=false;

byte m=alu.A[2];

short d=alu.address (page, m);

SCHAK=d;

break;}

case 0x11: {

name= «JB»+» «+Integer.toHexString(page);

ram.memChange=false;

if (alu.RF<0) SCHAK=alu.address (page, alu.A[2]);

else SCHAK++; break;}

case 0x12: {

name= «JNZ»+» «+Integer.toHexString(page);

ram.memChange=false;

if (alu.RF!=0) SCHAK=alu.address (page, alu.A[2]);

else SCHAK++; break;}

case 0x14: {

name= «MOVS»+» «+Integer.toHexString(page);

ram.AOP=alu.address (page, alu.A[0]);

ram.read();

alu.R1=ram.ROP;

ram.memChange=true;

alu.doMOVS(page);

SCHAK++; break;}

case 0x15: {

name= «CMPS»+» «+Integer.toHexString(page);

ram.memChange=false;

ram.AOP=alu.address (page, alu.A[0]);

ram.read();

alu.R1=ram.ROP;

ram.AOP=alu.address (page, alu.A[2]);

ram.read();

alu.R2=ram.ROP;

alu.doCMPS();

SCHAK++; break;}

case (byte) 0x1f: {name= «HALT»; isRunning=false; break;}

}

System.out.println («выполнена команда «+name);

out.print (name+»»);

if (name!= «HALT») {

System.out.println («А1 «+Integer.toHexString (alu.A[0]));

System.out.println («А2 «+Integer.toHexString (alu.A[1]));

System.out.println («А3 «+Integer.toHexString (alu.A[2]));

System.out.println («Р1 «+Integer.toHexString (alu.R1));

System.out.println («Р2 «+Integer.toHexString (alu.R2));

System.out.println («РФ «+Integer.toHexString (alu.RF));

System.out.println («РK «+Integer.toHexString (RK[0])+»»);

if (name== «MOVA»+((RK[0]>>>3)+1)+»») System.out.println (Integer.toHexString (RK[1]));

System.out.println («СЧАК «+Integer.toHexString(SCHAK));

if (name== «MOVA»+((RK[0]>>>3)+1)+»») out.print (Integer.toHexString (RK[1]));

if (ram.memChange) {

System.out.println («Записана переменная АОП = «+Integer.toHexString (ram.AOP));

System.out.println («РОП = «+Integer.toHexString (ram.ROP));

out.print (Integer.toHexString (ram.AOP)+»»);

out.print (Integer.toHexString (ram.ROP)+»»);

}

out.println (Integer.toHexString(SCHAK));

}

System.out.println();

alu.R1=0;

alu.R2=0;

RK[1]=0;}

finally { //out.close();

}

}

}

import java.io.*;

import java.lang.*;

import java.lang. Byte.*;

import java.lang. String.*;

public class Processor {

public RAM ram=new RAM();

public ALU alu=new ALU();

public UU uu=new UU();

static byte[] VXfile;

PrintWriter out;

public void input() throws IOException {

 // out=new FileWriter («Result.txt»);

byte d;

long toRead;

RandomAccessFile in=null;

int x=0, i=0; long m=0;

try {in=new RandomAccessFile («121.jar», «r»);

toRead=in.length();

m=in.length();

VXfile=new byte[(int) m];

while (toRead>0) {

d=in.readByte();

toRead-=1;

VXfile[i]=d;

i++;

}

}

catch (Exception e) {System.out.println(e);}

finally {

if (in==null) {in.close();}

}

short j=0; int k=0;

uu.SCHAK=alu.address (VXfile[1], VXfile[3]);

for (i=0; i<VXfile.length-2; i+=2)

switch (VXfile[i]) {

case 0: {byte p=VXfile [i+1], s=VXfile [i+3];

ram.AOP=alu.address (p, s);

i+=2;

break;}

case 1: {ram.ROP=VXfile [i+1];

ram.write();

ram.AOP++;

break;}}

}

public void out() throws IOException {

 // out=new FileWriter («Result.txt», true);

out=new PrintWriter («Result.txt»);

try {for (ram.AOP=0; ram.AOP<2048; ram.AOP++)

if((ram.AOP+1)%256!=0) {ram.read(); System.out.print (ram.ROP+»»);}

else System.out.println();

System.out.println();

for (ram.AOP=0; ram.AOP<2048; ram.AOP++)

if((ram.AOP+1)%256!=0) {ram.read(); out.print (ram.ROP+»»);}

else out.println();

out.println();}

finally { //out.close();

}

}

public void makingNull() {

for (ram.AOP=0; ram.AOP<2048; ram.AOP++)

{ram.ROP=0;

ram.write();}

uu.SCHAK=0;

uu.RK[0]=0;

uu.RK[1]=0;

alu.RF=0;

alu.A[0]=0;

alu.A[1]=0;

alu.A[2]=0;

}

public void makeAll() throws IOException {

while(uu.isRunning)

uu.steps();

}

public void makeOne() throws IOException {

if (uu.isRunning==true)

uu.steps();}

}

Размещено на Allbest.ru