Виртуальный процессор над битовыми строками Опции

[NoRToN]

Разработать виртуальный процессор для логических операций над битовыми строками.
Система команд – логические операции над содержимым 32-разрядных регистров , ввод и вывод содержимого регистров в шестнадцатеричной форме , считывание содержимого регистра в выделенный регистр (сумматор) и запись в регистр содержимого сумматора. Команды записываются в мнемонической форме с указанием имени регистра , в котором содержится один из операндов , второй операнд берётся из сумматора. Результат операции записывается в сумматор.
Дать описание системы команд и программу для вычисления значений булевской функции.
ПОМОГИТЕ. Заранее спасибо

[volvo]

NoRToN
Значит, так: вот набросок виртуального процессора. Это чтобы было понятно, чего от тебя хотят, и как вообще это делать...

Система команд:

in    <#> <значение> - заслать <значение> в регистр <#>
out <#> - показ значения регистра <регистр#>
mov <#> - переслать содержимое регистра <#> в сумматор
reg  <#> - переслать содержимое сумматора в регистр <#>
and  <#> - операция AND между значениями сумматора и регистра <#> Результат - в сумматоре
or    <#> - операция OR между значениями сумматора и регистра <#> Результат - в сумматоре
xor  <#> - операция XOR между значениями сумматора и регистра <#> Результат - в сумматоре
halt - останов процессора (выход из программы)

"Процессор" расчитан на 10 регистров...
Вот сама программа. Если есть баги - сильно не ругаться, посмотри на время поста... ;)

Код

uses crt;

const
 n = 10;
 alu = succ(n);
 rgs: array[1 .. n+1] of longint = {начальные значения - для отладки...}
   (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0);

type
 TWords =
   (rwError,
    rwIn, rwOut, rwMov, rwReg, rwAnd, rwOr, rwXor, rwHalt);

const
 words: array[TWords] of string =
   ('', 'in', 'out', 'mov', 'reg', 'and', 'or', 'xor', 'halt');
 letter: array[boolean] of char =
   ('0', '1');
procedure print_reg(i: integer);
 var x: longint;
 begin
   x := rgs[i];
   for i := 0 to 31 do
     write( letter[((x shl i) and $80000000) = $80000000] );
 end;

procedure show_cpu;
 var i: integer;
 begin
   for i := 1 to n do
     begin
       gotoxy(1, i); write('reg(', i, '):');
       gotoxy(20, i); print_reg(i)
     end;

   gotoxy(1, n+3); write('sum: ');
   gotoxy(20, n+3); print_reg(n+1);
 end;

function get_command: boolean;
 procedure print_error;
   begin
     gotoxy(1, n+5); write('>> ILLEGAL INSTRUCTION <Enter>');
     readln
   end;

 function find_word(s: string): TWords;
   var i: TWords;
   begin
     for i := succ(low(TWords)) to high(TWords) do
       if s = words[i] then
         begin
           find_word := i; exit
         end;
     find_word := rwError
   end;

 function next_token(s: string; var x: longint;
          max: longint): boolean;
   var err: integer;
   begin
     next_token := false;
     if s = '' then exit;

     while s[1] = ' ' do
       delete(s, 1, 1);
     val(s, x, err);
     next_token :=
       ((err <> 0) or (x <= 0) or (x > max))
   end;

 var
   s, s_oper: string;
   p: byte;
   found: TWords;
   value, data: longint;
 begin
   gotoxy(1, n+5); write('':55);
   gotoxy(1, n+5); write('>');
   readln(s);

   p := pos(' ', s);
   if p > 0 then
     begin
       s_oper := copy(s, 1, pred(p));
       delete(s, 1, p)
     end
   else s_oper := s;

   get_command := false;
   found := find_word(s_oper);
   case found of
     rwOut .. rwXor:
       begin
         if next_token({copy(s, 1, pred(pos(' ', s)))}s, value, n)
           then print_error {error occured}
           else
             begin
               case found of
                 rwOut:
                   begin
                     gotoxy(1, n+5); write('>> reg(', value, ') = ', rgs[value], ' <Enter>');
                     readln
                   end;
                 rwMov: rgs[alu] := rgs[value];
                 rwReg: rgs[value] := rgs[alu];
                 rwAnd: rgs[alu] := rgs[alu] and rgs[value];
                 rwOr: rgs[alu] := rgs[alu] or rgs[value];
                 rwXor: rgs[alu] := rgs[alu] xor rgs[value];
               end;
               get_command := false;
               exit
             end;
       end;
     rwIn:
       begin
         if next_token(copy(s, 1, pred(pos(' ', s))), value, n)
           then print_error {error occured}
           else
             begin
               delete(s, 1, pos(' ', s));
               if next_token(s, data, maxlongint)
                 then print_error {error occured}
                 else
                   begin
                     rgs[value] := data;
                     get_command := false;
                     exit
                   end;
             end;
       end;
     rwHalt:
       get_command := true;
   else
     print_error {error occured}
   end;
 end;

var
 stopped: boolean;

begin
 clrscr;
 stopped := false;
 repeat
   show_cpu;
   stopped := get_command;
 until stopped;

end.