public static void RegisterTo(IVirtualMachine vm)
{
var indexOfSquareBrackets = new Stack <int>();
var squareBracketsDict = new Dictionary <int, int>();
for (int i = 0; i < vm.Instructions.Length; i++)
{
if (vm.Instructions[i] == '[')
{
indexOfSquareBrackets.Push(i);
}
if (vm.Instructions[i] == ']')
{
var tempIndex = indexOfSquareBrackets.Pop();
squareBracketsDict.Add(tempIndex, i);
squareBracketsDict.Add(i, tempIndex);
}
}
vm.RegisterCommand('[', virtMachine =>
{
if (vm.Memory[vm.MemoryPointer] == 0)
{
vm.InstructionPointer = squareBracketsDict[vm.InstructionPointer];
}
});
vm.RegisterCommand(']', virtMachine =>
{
if (vm.Memory[vm.MemoryPointer] != 0)
{
vm.InstructionPointer = squareBracketsDict[vm.InstructionPointer];
}
});
}
// Увеличение/уменьшение байта памяти, на который указывает указатель
private static void RegisterIncNDec(IVirtualMachine vm)
{
vm.RegisterCommand('+', vMachine =>
{
// Если значение байта максимально, то при увеличении значение становится 0
if (vMachine.Memory[vMachine.MemoryPointer] == 255)
{
vMachine.Memory[vMachine.MemoryPointer] = 0;
}
else
{
vMachine.Memory[vMachine.MemoryPointer]++;
}
});
vm.RegisterCommand('-', vMachine =>
{
if (vMachine.Memory[vMachine.MemoryPointer] == 0) // Аналогично инкрименту
{
vMachine.Memory[vMachine.MemoryPointer] = 255;
}
else
{
vMachine.Memory[vMachine.MemoryPointer]--;
}
});
}
public static void RegisterTo(IVirtualMachine vm)
{
var jumpMachine = new JumpMachine(vm.Instructions);
vm.RegisterCommand('[', b => jumpMachine.OnBrace(b));
vm.RegisterCommand(']', b => jumpMachine.OnBrace(b));
}
public static void RegisterTo(IVirtualMachine vm)
{
var pogoStick = new PogoStick(vm.Instructions);
vm.RegisterCommand('[', b => pogoStick.OnBrace(b));
vm.RegisterCommand(']', b => pogoStick.OnBrace(b));
}
public static void RegisterTo(IVirtualMachine vm)
{
var st = new Stack <int>();
var leftToRight = new Dictionary <int, int>();
var rightToLeft = new Dictionary <int, int>();
for (var i = 0; i < vm.Instructions.Length; i++)
{
var instruction = vm.Instructions[i];
if (instruction == '[')
{
st.Push(i);
}
else if (instruction == ']')
{
var popIndex = st.Pop();
leftToRight.Add(popIndex, i);
rightToLeft.Add(i, popIndex);
}
}
vm.RegisterCommand('[', b =>
{
if (vm.Memory[vm.MemoryPointer] == 0)
{
vm.InstructionPointer = leftToRight[vm.InstructionPointer];
}
});
vm.RegisterCommand(']', b => {
if (vm.Memory[vm.MemoryPointer] != 0)
{
vm.InstructionPointer = rightToLeft[vm.InstructionPointer];
}
});
}
// Сдвинуть указатель памяти вправо/влево на 1 байт
private static void RegisterRigthSNLefthift(IVirtualMachine vm)
{
vm.RegisterCommand('>', vMachine =>
{
// Если указатель памяти указывает на последнюю ячейку памяти, то ставим его в начало
if (vMachine.MemoryPointer + 1 == vMachine.Memory.Length)
{
vMachine.MemoryPointer = 0;
}
else
{
vMachine.MemoryPointer++;
}
});
vm.RegisterCommand('<', vMachine =>
{
if (vMachine.MemoryPointer == 0) // Аналогично сдвигу вправо
{
vMachine.MemoryPointer = vMachine.Memory.Length - 1;
}
else
{
vMachine.MemoryPointer--;
}
});
}
public static void RegisterTo(IVirtualMachine vm)
{
var x = new Stack <MutablePair <int, int> >();
var loops = ass(vm.Instructions);
vm.RegisterCommand('[', b =>
{
/*var count = b.Memory[b.MemoryPointer];
* if (count == 0)
* //b.InstructionPointer = loops.FindIndex();
* else
* x.Push(new MutablePair<int, int>(b.InstructionPointer, count));*/
});
vm.RegisterCommand(']', b =>
{
var count = x.Peek().Item2;
if (count < 2)
{
x.Pop();
return;
}
x.Peek().Item2--;
b.InstructionPointer = x.Peek().Item1;
});
}
public static void RegisterTo(IVirtualMachine vm)
{
var indexOfBrackets = new Stack <int>();
var startBrackets = new Dictionary <int, int>();
var endBrackets = new Dictionary <int, int>();
for (int i = 0; i < vm.Instructions.Length; i++)
{
if (vm.Instructions[i] == '[')
{
indexOfBrackets.Push(i);
}
else if (vm.Instructions[i] == ']')
{
startBrackets[i] = indexOfBrackets.Peek();
endBrackets[indexOfBrackets.Pop()] = i;
}
}
vm.RegisterCommand('[', b => {
if (vm.Memory[vm.MemoryPointer] == 0)
{
vm.InstructionPointer = endBrackets[vm.InstructionPointer];
}
});
vm.RegisterCommand(']', b => vm.InstructionPointer = startBrackets[vm.InstructionPointer] - 1);
}
private static void Shift(IVirtualMachine vm)
{
vm.RegisterCommand('>', b =>
{
if (b.MemoryPointer == b.Memory.Length - 1)
{
b.MemoryPointer = 0;
}
else
{
b.MemoryPointer++;
}
});
vm.RegisterCommand('<', b =>
{
if (b.MemoryPointer == 0)
{
b.MemoryPointer = b.Memory.Length - 1;
}
else
{
b.MemoryPointer--;
}
});
}
private static void IncAndDec(IVirtualMachine vm)
{
vm.RegisterCommand('+', b =>
{
var element = b.Memory[b.MemoryPointer];
if (element == 255)
{
element = 0;
}
else
{
element++;
}
b.Memory[b.MemoryPointer] = element;
});
vm.RegisterCommand('-', b =>
{
var element = b.Memory[b.MemoryPointer];
if (element == 0)
{
element = 255;
}
else
{
element--;
}
b.Memory[b.MemoryPointer] = element;
});
}
public static void RegisterTo(IVirtualMachine vm)
{
var halfLoops = new Stack <Loop>();
startLoops = new Dictionary <int, Loop>();
endLoops = new Dictionary <int, Loop>();
for (int position = 0; position < vm.Instructions.Length; position++)
{
if (vm.Instructions[position] == '[')
{
halfLoops.Push(new Loop(position));
}
else if (vm.Instructions[position] == ']')
{
var loop = halfLoops.Pop();
loop.End = position;
startLoops.Add(loop.Start, loop);
endLoops.Add(loop.End, loop);
}
}
vm.RegisterCommand('[', b => {
if (vm.Memory[vm.MemoryPointer] == 0)
{
vm.InstructionPointer = startLoops[vm.InstructionPointer].End;
}
});
vm.RegisterCommand(']', b => {
if (vm.Memory[vm.MemoryPointer] != 0)
{
vm.InstructionPointer = endLoops[vm.InstructionPointer].Start;
}
});
}
public static void RegisterTo(IVirtualMachine vm, Func <int> read, Action <char> write)
{
Constant.Constants(vm);
RightOrLeftByteShift(vm);
IncOrDecByte(vm);
vm.RegisterCommand('.', machine => write((char)machine.Memory[machine.MemoryPointer]));
vm.RegisterCommand(',', machine => machine.Memory[machine.MemoryPointer] = (byte)read());
}
public static void RegisterTo(IVirtualMachine vm, Func <int> read, Action <char> write)
{
// Добавление команд вывода и записи с помощью функ. write и read
vm.RegisterCommand('.', vMachine => write((char)vMachine.Memory[vMachine.MemoryPointer]));
vm.RegisterCommand(',', vMachine => vMachine.Memory[vMachine.MemoryPointer] = (byte)read());
// Добавление остальных команд
RegisterIncNDec(vm);
RegisterRigthSNLefthift(vm);
RegisterConstants(vm);
}
public static void RightOrLeftByteShift(IVirtualMachine vm)
{
vm.RegisterCommand('<', machine =>
{
machine.MemoryPointer = Calc(machine.MemoryPointer, -1, machine.Memory.Length);
});
vm.RegisterCommand('>', machine =>
{
machine.MemoryPointer = Calc(machine.MemoryPointer, 1, machine.Memory.Length);
});
}
public static void RegisterTo(IVirtualMachine vm, Func <int> read, Action <char> write)
{
vm.RegisterCommand('.', b =>
{
write((char)vm.Memory[vm.MemoryPointer]);
});
vm.RegisterCommand('+', b =>
{
if (vm.Memory[vm.MemoryPointer] == 255)
{
vm.Memory[vm.MemoryPointer] = 0;
}
else
{
vm.Memory[vm.MemoryPointer]++;
}
});
vm.RegisterCommand('-', b =>
{
if (vm.Memory[vm.MemoryPointer] == 0)
{
vm.Memory[vm.MemoryPointer] = 255;
}
else
{
vm.Memory[vm.MemoryPointer]--;
}
});
vm.RegisterCommand('>', b =>
{
if (vm.MemoryPointer == vm.Memory.Length - 1)
{
vm.MemoryPointer = 0;
}
else
{
vm.MemoryPointer++;
}
});
vm.RegisterCommand('<', b =>
{
if (vm.MemoryPointer == 0)
{
vm.MemoryPointer = vm.Memory.Length - 1;
}
else
{
vm.MemoryPointer--;
}
});
}
public static void RegisterTo(IVirtualMachine vm)
{
var instruction = new Instruction();
instruction.AddToDictionary(vm.Instructions);
vm.RegisterCommand('[', b =>
{
if (b.Memory[b.MemoryPointer] == 0)
{
b.InstructionPointer = instruction.Begin[b.InstructionPointer];
}
});
vm.RegisterCommand(']', b => b.InstructionPointer = instruction.End[b.InstructionPointer] - 1);
}
public static void WriteAllSymbols(IVirtualMachine vm)
{
foreach (var symbol in allSymbols)
{
vm.RegisterCommand(symbol, machine => machine.Memory[machine.MemoryPointer] = (byte)symbol);
}
}
// Добавление констант
private static void RegisterConstants(IVirtualMachine vm)
{
foreach (var c in consts)
{
vm.RegisterCommand(c, vMachine => vMachine.Memory[vMachine.MemoryPointer] = (byte)c);
}
}
public static void Constants(IVirtualMachine vm)
{
foreach (var chars in constant)
{
vm.RegisterCommand(chars, machine => machine.Memory[machine.MemoryPointer] = (byte)chars);
}
}
private static void AddNewKeys(char v1, char v2, IVirtualMachine vm)
{
for (int i = v1; i <= v2; i++)
{
var item = i;
vm.RegisterCommand((char)item, b => { b.Memory[vm.MemoryPointer] = (byte)item; });
}
}
public static void RegisterTo(IVirtualMachine vm, Func <int> read, Action <char> write)
{
vm.RegisterCommand('.', b => write(Convert.ToChar(b.Memory[b.MemoryPointer])));
vm.RegisterCommand('+', b =>
{
b.Memory[b.MemoryPointer] = Convert.ToByte((b.Memory[b.MemoryPointer] + 1) & 0xFF);
});
vm.RegisterCommand('-', b =>
{
b.Memory[b.MemoryPointer] = Convert.ToByte((b.Memory[b.MemoryPointer] + 255) & 0xFF);
});
vm.RegisterCommand(',', b => { b.Memory[b.MemoryPointer] = Convert.ToByte(read()); });
vm.RegisterCommand('>', b => { b.MemoryPointer = (b.MemoryPointer + 1) % b.Memory.Length; });
vm.RegisterCommand('<', b =>
{
b.MemoryPointer = (b.MemoryPointer + b.Memory.Length - 1) % b.Memory.Length;
});
const string literals = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
for (var ix = 0; ix < literals.Length; ix++)
{
var literal = literals[ix];
vm.RegisterCommand(literal, b => { b.Memory[b.MemoryPointer] = Convert.ToByte(literal); });
}
}
public static void RegisterTo(IVirtualMachine vm, Func <int> read, Action <char> write)
{
// Вывести байт памяти, на который указывает указатель, преобразовав в символ согласно ASCII
vm.RegisterCommand('.', b => { write(Convert.ToChar(b.Memory[b.MemoryPointer])); });
// Увеличить байт памяти, на который указывает указатель
vm.RegisterCommand('+', b => { b.Memory[b.MemoryPointer] = Convert.ToByte((b.Memory[b.MemoryPointer] + 1) & 0xFF); });
// Уменьшить байт памяти, на который указывает указатель
vm.RegisterCommand('-', b => { b.Memory[b.MemoryPointer] = Convert.ToByte((b.Memory[b.MemoryPointer] + 255) & 0xFF); });
// Ввести символ и сохранить его ASCII-код в байт памяти, на который указывает указатель
vm.RegisterCommand(',', b => { b.Memory[b.MemoryPointer] = Convert.ToByte(read()); });
// Сдвинуть указатель памяти вправо на 1 байт
vm.RegisterCommand('>', b => { b.MemoryPointer = (b.MemoryPointer + 1) % b.Memory.Length; });
// Сдвинуть указатель памяти влево на 1 байт
vm.RegisterCommand('<', b =>
{
b.MemoryPointer = (b.MemoryPointer + b.Memory.Length - 1) % b.Memory.Length;
});
// сохранить ASCII-код этого символа в байт памяти, на который указывает указатель
const string literals = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
for (var ix = 0; ix < literals.Length; ix++)
{
var literal = literals[ix];
vm.RegisterCommand(literal, b => { b.Memory[b.MemoryPointer] = Convert.ToByte(literal); });
}
}
//Добавление комманд для brainfuck языка
public static void RegisterTo(IVirtualMachine vm)
{
var braces = FindBraces(vm.Instructions);
vm.RegisterCommand('[', b =>
{ if (b.Memory[b.MemoryPointer] == 0)
{
b.InstructionPointer = braces[b.InstructionPointer];
}
});
vm.RegisterCommand(']', b =>
{ if (b.Memory[b.MemoryPointer] != 0)
{
b.InstructionPointer = braces[b.InstructionPointer];
}
});
}
private static void RegisterConstantCommands(IVirtualMachine vm)
{
for (var ch = 'a'; ch <= 'z'; ++ch)
{
var lowercase = ch;
vm.RegisterCommand(lowercase, b =>
{ b.Memory[b.MemoryPointer] = Convert.ToByte(lowercase); });
var uppercase = char.ToUpper(ch);
vm.RegisterCommand(uppercase, b =>
{ b.Memory[b.MemoryPointer] = Convert.ToByte(uppercase); });
}
for (var ch = '0'; ch <= '9'; ++ch)
{
var number = ch;
vm.RegisterCommand(number, b =>
{ b.Memory[b.MemoryPointer] = Convert.ToByte(number); });
}
}
public static void RegisterTo(IVirtualMachine vm)
{
FindBrackets(vm);
vm.RegisterCommand('[', b =>
{
if (b.Memory[b.MemoryPointer] == 0)
{
b.InstructionPointer = BracketBegin[b.InstructionPointer];
}
});
vm.RegisterCommand(']', b =>
{
if (b.Memory[b.MemoryPointer] != 0)
{
b.InstructionPointer = BracketEnd[b.InstructionPointer];
}
});
}
public static void RegisterTo(IVirtualMachine vm)
{
Dictionary <int, int> loopsByStart = new Dictionary <int, int>();
Stack <int> currentLoopsByStart = new Stack <int>();
vm.RegisterCommand('[', b =>
{
if (loopsByStart.Count == 0)
{
Stack <int> startOfLoops = new Stack <int>();
startOfLoops.Push(b.InstructionPointer);
for (int tempIndex = b.InstructionPointer + 1; tempIndex != b.Instructions.Length; tempIndex++)
{
if (b.Instructions[tempIndex] == '[')
{
startOfLoops.Push(tempIndex);
}
else if (b.Instructions[tempIndex] == ']')
{
loopsByStart[startOfLoops.Pop()] = tempIndex;
}
}
}
if (b.Memory[b.MemoryPointer] == 0)
{
b.InstructionPointer = loopsByStart[b.InstructionPointer];
}
else
{
currentLoopsByStart.Push(b.InstructionPointer);
}
});
vm.RegisterCommand(']', b =>
{
if (b.Memory[b.MemoryPointer] != 0)
{
b.InstructionPointer = currentLoopsByStart.Peek();
}
else
{
currentLoopsByStart.Pop();
}
});
}
public static void RegisterTo(IVirtualMachine vm)
{
var bracketPairs = GetBracketPairs(vm.Instructions);
vm.RegisterCommand('[', b =>
{
if (vm.Memory[vm.MemoryPointer] == 0)
{
vm.InstructionPointer = bracketPairs[vm.InstructionPointer];
}
});
vm.RegisterCommand(']', b =>
{
if (vm.Memory[vm.MemoryPointer] != 0)
{
vm.InstructionPointer = bracketPairs[vm.InstructionPointer];
}
});
}
public static void RegisterTo(IVirtualMachine vm)
{
var pairs = vm.FindLoopPairs();
vm.RegisterCommand('[', b =>
{
if (b.GetCell() == 0)
{
b.InstructionPointer = pairs[b.InstructionPointer];
}
});
vm.RegisterCommand(']', b =>
{
if (b.GetCell() != 0)
{
b.InstructionPointer = pairs[b.InstructionPointer];
}
});
}
public static void RegisterTo(IVirtualMachine vm)
{
BodyLoop(vm);
vm.RegisterCommand('[', machine =>
{
if (machine.Memory[machine.MemoryPointer] == 0)
{
machine.InstructionPointer = Bracket[machine.InstructionPointer];
}
});
vm.RegisterCommand(']', machine =>
{
if (machine.Memory[machine.MemoryPointer] != 0)
{
machine.InstructionPointer = ClosingBracket[machine.InstructionPointer];
}
});
}
public static void RegisterTo(IVirtualMachine vm)
{
WriteLoopsLocation(vm);
IsFirst = false;
vm.RegisterCommand('[', b =>
{
if (b.Memory[b.MemoryPointer] == 0)
{
b.InstructionPointer = LoopsLocation[b.InstructionPointer];
}
});
vm.RegisterCommand(']', b =>
{
if (b.Memory[b.MemoryPointer] != 0)
{
b.InstructionPointer = LoopsLocation[b.InstructionPointer];
}
});
}
