public static void Main(string[] args)
{
Console.WriteLine("Started");
//Validate Args were provided
if (args.Length != 1)
{
Console.WriteLine("missing args");
System.Environment.Exit(1);
}
//open data file
InFile puzzleData = new InFile(args[0]);
Console.WriteLine("File read.");
//exit program if data file unreadable
if (puzzleData.OpenError())
{
Console.WriteLine("Failed to open " + args[0]);
System.Environment.Exit(1);
}
//process data file
string[] data = new string[9];
for (int i = 0; i < data.Length; i++)
{
data[i] = puzzleData.ReadLine();
}
for (int i = 0; i < data.Length; i++)
{
Console.WriteLine(data[i]);
}
}
static void readBoard(string[,] board, int[, ][,] suggestedBoard, InFile data, bool solution)
{
int row = 0, col = 0;
while (row != 9 && !data.NoMoreData())
{
int num = data.ReadInt();
if (num == 0)
{
board[row, col] = "..";
if (!solution)
{
suggestedBoard[row, col] = new int[3, 3] {
{ 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 }
};
}
}
else
{
board[row, col] = " " + num;
if (!solution)
{
suggestedBoard[row, col] = null;
known++;
}
}
col++;
if (col == 9)
{
row++;
col = 0;
}
}
/*if the board just filled was not the solution then
* skip next three lines to get to the next board (which is the solution board)*/
if (!solution)
{
data.ReadLine();
data.ReadLine();
data.ReadLine();
}
}
private void Form1_Load(object sender, EventArgs e)
{
//Code which Changes the visibility of Form.
ProductPanel.Visible = true;
ButtonPanelOne.Visible = false;
ExitButtonTwo.Visible = true;
DataGridViewPanel.Visible = false;
//The Opening stock is loaded from the file and stored in stock array.
StreamReader InFile;
InFile = File.OpenText("StockFile.txt");
for (int i = 0; i < 14; i++)
{
for (int j = 0; j < 5; j++)
{
StockArray[i, j] = int.Parse(InFile.ReadLine());
}
}
InFile.Close();
//code in which loaded Stock is copied to Temporary Array for daily operation.
Array.Copy(StockArray, TempStockArray, StockArray.Length);
}
} // PVM.InBounds
public static void Emulator(int initPC, int codeLen, int initSP,
InFile data, OutFile results, bool tracing,
bool traceStack, bool traceHeap)
{
// Emulates action of the codeLen instructions stored in mem[0 .. codeLen-1], with
// program counter initialized to initPC, stack pointer initialized to initSP.
// data and results are used for I/O. Tracing at the code level may be requested
int pcNow; // current program counter
int loop; // internal loops
int tos, sos; // values popped from stack
int adr; // effective address for memory accesses
int target; // destination for branches
stackBase = initSP;
heapBase = codeLen; // initialize boundaries
cpu.hp = heapBase; // initialize registers
cpu.sp = stackBase;
cpu.gp = stackBase;
cpu.mp = stackBase;
cpu.fp = stackBase;
cpu.pc = initPC; // initialize program counter
for (int i = heapBase; i < stackBase; i++)
{
mem[i] = 0; // set entire memory to null or 0
}
ps = running; // prepare to execute
int ops = 0;
timer.Start();
do
{
ops++;
pcNow = cpu.pc; // retain for tracing/postmortem
if (cpu.pc < 0 || cpu.pc >= codeLen)
{
ps = badAdr;
break;
}
cpu.ir = Next(); // fetch
if (tracing)
{
Trace(results, pcNow, traceStack, traceHeap);
}
switch (cpu.ir) // execute
{
case PVM.nop: // no operation
break;
case PVM.dsp: // decrement stack pointer (allocate space for variables)
int localSpace = Next();
cpu.sp -= localSpace;
if (InBounds(cpu.sp)) // initialize all local variables to zero/null
{
for (loop = 0; loop < localSpace; loop++)
{
mem[cpu.sp + loop] = 0;
}
}
break;
case PVM.ldc: // push constant value
Push(Next());
break;
case PVM.ldc_m1: // push constant -1
Push(-1);
break;
case PVM.ldc_0: // push constant 0
Push(0);
break;
case PVM.ldc_1: // push constant 1
Push(1);
break;
case PVM.ldc_2: // push constant 2
Push(2);
break;
case PVM.ldc_3: // push constant 3
Push(3);
break;
case PVM.ldc_4: // push constant 4
Push(4);
break;
case PVM.ldc_5: // push constant 5
Push(5);
break;
case PVM.dup: // duplicate top of stack
tos = Pop();
Push(tos); Push(tos);
break;
case PVM.rdup: // Remove top of stack
tos = Pop();
break;
case PVM.lda: // push local address
adr = cpu.fp - 1 - Next();
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.lda_0: // push local address 0
adr = cpu.fp - 1;
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.lda_1: // push local address 1
adr = cpu.fp - 2;
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.lda_2: // push local address 2
adr = cpu.fp - 3;
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.lda_3: // push local address 3
adr = cpu.fp - 4;
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.lda_4: // push local address 4
adr = cpu.fp - 5;
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.lda_5: // push local address 5
adr = cpu.fp - 6;
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.ldl: // push local value
adr = cpu.fp - 1 - Next();
if (InBounds(adr))
{
Push(mem[adr]);
}
break;
case PVM.ldl_0: // push value of local variable 0
adr = cpu.fp - 1;
if (InBounds(adr))
{
Push(mem[adr]);
}
break;
case PVM.ldl_1: // push value of local variable 1
adr = cpu.fp - 2;
if (InBounds(adr))
{
Push(mem[adr]);
}
break;
case PVM.ldl_2: // push value of local variable 2
adr = cpu.fp - 3;
if (InBounds(adr))
{
Push(mem[adr]);
}
break;
case PVM.ldl_3: // push value of local variable 3
adr = cpu.fp - 4;
if (InBounds(adr))
{
Push(mem[adr]);
}
break;
case PVM.ldl_4: // push value of local variable 4
adr = cpu.fp - 5;
if (InBounds(adr))
{
Push(mem[adr]);
}
break;
case PVM.ldl_5: // push value of local variable 5
adr = cpu.fp - 6;
if (InBounds(adr))
{
Push(mem[adr]);
}
break;
case PVM.stl: // store local value
adr = cpu.fp - 1 - Next();
if (InBounds(adr))
{
mem[adr] = Pop();
}
break;
case PVM.stlc: // character checked pop to local variable
tos = Pop(); adr = cpu.fp - 1 - Next();
if (InBounds(adr))
{
if (tos >= 0 && tos <= maxChar)
{
mem[adr] = tos;
}
else
{
ps = badVal;
}
}
break;
case PVM.stl_0: // pop to local variable 0
adr = cpu.fp - 1;
if (InBounds(adr))
{
mem[adr] = Pop();
}
break;
case PVM.stl_1: // pop to local variable 1
adr = cpu.fp - 2;
if (InBounds(adr))
{
mem[adr] = Pop();
}
break;
case PVM.stl_2: // pop to local variable 2
adr = cpu.fp - 3;
if (InBounds(adr))
{
mem[adr] = Pop();
}
break;
case PVM.stl_3: // pop to local variable 3
adr = cpu.fp - 4;
if (InBounds(adr))
{
mem[adr] = Pop();
}
break;
case PVM.stl_4: // pop to local variable 4
adr = cpu.fp - 5;
if (InBounds(adr))
{
mem[adr] = Pop();
}
break;
case PVM.stl_5: // pop to local variable 5
adr = cpu.fp - 6;
if (InBounds(adr))
{
mem[adr] = Pop();
}
break;
case PVM.ldv: // dereference
adr = Pop();
if (InBounds(adr))
{
Push(mem[adr]);
}
break;
case PVM.sto: // store
tos = Pop(); adr = Pop();
if (InBounds(adr))
{
mem[adr] = tos;
}
break;
case PVM.stoc: // character checked store
tos = Pop(); adr = Pop();
if (InBounds(adr))
{
if (tos >= 0 && tos <= maxChar)
{
mem[adr] = tos;
}
else
{
ps = badVal;
}
}
break;
case PVM.ldxa: // heap array indexing
adr = Pop();
int heapPtr = Pop();
if (heapPtr == 0)
{
ps = nullRef;
}
else if (heapPtr < heapBase || heapPtr >= cpu.hp)
{
ps = badMem;
}
else if (adr < 0 || adr >= mem[heapPtr])
{
ps = badInd;
}
else
{
Push(heapPtr + adr + 1);
}
break;
case PVM.inpi: // integer input
adr = Pop();
if (InBounds(adr))
{
mem[adr] = data.ReadInt();
if (data.Error())
{
ps = badData;
}
}
break;
case PVM.inpb: // boolean input
adr = Pop();
if (InBounds(adr))
{
mem[adr] = data.ReadBool() ? 1 : 0;
if (data.Error())
{
ps = badData;
}
}
break;
case PVM.inpc: // character input
adr = Pop();
if (InBounds(adr))
{
mem[adr] = data.ReadChar();
if (data.Error())
{
ps = badData;
}
}
break;
case PVM.inpl: // skip to end of input line
data.ReadLine();
break;
case PVM.i2c: // check (char) cast is in range
if (mem[cpu.sp] < 0 || mem[cpu.sp] > maxChar)
{
ps = badVal;
}
break;
case PVM.prni: // integer output
if (tracing)
{
results.Write(padding);
}
results.Write(Pop(), 0);
if (tracing)
{
results.WriteLine();
}
break;
case PVM.prnb: // boolean output
if (tracing)
{
results.Write(padding);
}
if (Pop() != 0)
{
results.Write(" true ");
}
else
{
results.Write(" false ");
}
if (tracing)
{
results.WriteLine();
}
break;
case PVM.prnc: // character output
if (tracing)
{
results.Write(padding);
}
results.Write((char)(Math.Abs(Pop()) % (maxChar + 1)), 1);
if (tracing)
{
results.WriteLine();
}
break;
case PVM.prns: // string output
if (tracing)
{
results.Write(padding);
}
loop = Next();
while (ps == running && mem[loop] != 0)
{
results.Write((char)mem[loop]); loop--;
if (loop < stackBase)
{
ps = badMem;
}
}
if (tracing)
{
results.WriteLine();
}
break;
case PVM.fprns: // string output
if (tracing)
{
results.Write(padding);
}
loop = Next();
StringBuilder str = new StringBuilder();
while (ps == running && mem[loop] != 0)
{
//results.Write((char) mem[loop]); loop--;
str.Append((char)mem[loop]); loop--;
if (loop < stackBase)
{
ps = badMem;
}
}
results.Write(str.ToString(), Pop());
if (tracing)
{
results.WriteLine();
}
break;
case PVM.prnl: // newline
results.WriteLine();
break;
case PVM.fprint:
tos = Pop();
sos = Pop();
results.Write(sos, tos);
break;
case PVM.neg: // integer negation
Push(-Pop());
break;
case PVM.add: // integer addition
tos = Pop(); Push(Pop() + tos);
break;
case PVM.sub: // integer subtraction
tos = Pop(); Push(Pop() - tos);
break;
case PVM.mul: // integer multiplication
tos = Pop();
sos = Pop();
if (tos != 0 && Math.Abs(sos) > maxInt / Math.Abs(tos))
{
ps = badVal;
}
else
{
Push(sos * tos);
}
break;
case PVM.div: // integer division (quotient)
tos = Pop();
if (tos == 0)
{
ps = divZero;
}
else
{
Push(Pop() / tos);
}
break;
case PVM.max: // Finds max. First Pops elements off stack
// to see how many elements.
int numElements = Pop();
if (numElements == 0)
{
ps = noData;
}
else
{
List <int> maxElements = new List <int> ();
for (int i = 0; i < numElements; i++)
{
maxElements.Add(Pop());
}
maxElements.Sort();
maxElements.Reverse();
Push(maxElements[0]);
}
break;
case PVM.min: // Finds min. First Pops elements off stack
// to see how many elements
int numMin = Pop();
if (numMin == 0)
{
ps = noData;
}
else
{
List <int> minElements = new List <int> ();
for (int i = 0; i < numMin; i++)
{
minElements.Add(Pop());
}
minElements.Sort();
Push(minElements[0]);
}
break;
case PVM.sqrt: // Square root
tos = Pop();
Push(Convert.ToInt32(System.Math.Sqrt(tos)));
break;
case PVM.rem: // integer division (remainder)
tos = Pop();
if (tos == 0)
{
ps = divZero;
}
else
{
Push(Pop() % tos);
}
break;
case PVM.not: // logical negation
Push(Pop() == 0 ? 1 : 0);
break;
case PVM.and: // logical and
tos = Pop(); Push(Pop() & tos);
break;
case PVM.or: // logical or
tos = Pop(); Push(Pop() | tos);
break;
case PVM.ceq: // logical equality
tos = Pop(); Push(Pop() == tos ? 1 : 0);
break;
case PVM.cne: // logical inequality
tos = Pop(); Push(Pop() != tos ? 1 : 0);
break;
case PVM.clt: // logical less
tos = Pop(); Push(Pop() < tos ? 1 : 0);
break;
case PVM.cle: // logical less or equal
tos = Pop(); Push(Pop() <= tos ? 1 : 0);
break;
case PVM.cgt: // logical greater
tos = Pop(); Push(Pop() > tos ? 1 : 0);
break;
case PVM.cge: // logical greater or equal
tos = Pop(); Push(Pop() >= tos ? 1 : 0);
break;
case PVM.brn: // unconditional branch
cpu.pc = Next();
if (cpu.pc < 0 || cpu.pc >= codeLen)
{
ps = badAdr;
}
break;
case PVM.bze: // pop top of stack, branch if false
target = Next();
if (Pop() == 0)
{
cpu.pc = target;
if (cpu.pc < 0 || cpu.pc >= codeLen)
{
ps = badAdr;
}
}
break;
case PVM.bfalse: // conditional short circuit "and" branch
target = Next();
if (mem[cpu.sp] == 0)
{
cpu.pc = target;
}
else
{
cpu.sp++;
}
break;
case PVM.btrue: // conditional short circuit "or" branch
target = Next();
if (mem[cpu.sp] == 1)
{
cpu.pc = target;
}
else
{
cpu.sp++;
}
break;
case PVM.anew: // heap array allocation
int size = Pop();
if (size <= 0 || size + 1 > cpu.sp - cpu.hp - 2)
{
ps = badAll;
}
else
{
mem[cpu.hp] = size; // first element stores size for bounds checking
Push(cpu.hp);
cpu.hp += size + 1; // bump heap pointer
// elements are already initialized to 0 / null (why?)
}
break;
case PVM.halt: // halt
ps = finished;
break;
case PVM.inc: // integer ++
adr = Pop();
if (InBounds(adr))
{
mem[adr]++;
}
break;
case PVM.dec: // integer --
adr = Pop();
if (InBounds(adr))
{
mem[adr]--;
}
break;
case PVM.incc: // ++ characters
adr = Pop();
if (InBounds(adr))
{
if (mem[adr] < maxChar)
{
mem[adr]++;
}
else
{
ps = badVal;
}
}
break;
case PVM.decc: // -- characters
adr = Pop();
if (InBounds(adr))
{
if (mem[adr] > 0)
{
mem[adr]--;
}
else
{
ps = badVal;
}
}
break;
case cpy:
int addrC1 = Pop();
int addrC2 = Pop();
int addrLengthC1 = mem[mem[addrC1]];
int addrLengthC2 = mem[mem[addrC2]];
if (addrLengthC1 != addrLengthC2)
{
ps = badVal;
}
else
{
int i = 1;
while ((i <= addrLengthC1))
{
mem[mem[addrC2] + i] = mem[mem[addrC1] + i];
i++;
}
}
break;
case eql:
int addr1 = Pop();
int addr2 = Pop();
int addrLength1 = mem[mem[addr1]];
int addrLength2 = mem[mem[addr2]];
if (addrLength1 != addrLength2)
{
Push(0); // push flase if lenghts arnt ==
}
else
{
bool isEqual = true;
int i = 1;
while (i < addrLength1 + 1)
{
if (mem[mem[addr1] + i] != mem[mem[addr2] + i])
{
isEqual = false;
}
i++;
}
if (isEqual)
{
Push(1);
}
else
{
Push(0);
}
}
break;
case PVM.stack: // stack dump (debugging)
StackDump(results, pcNow);
break;
case PVM.heap: // heap dump (debugging)
HeapDump(results, pcNow);
break;
case PVM.fhdr: // allocate frame header
if (InBounds(cpu.sp - headerSize))
{
mem[cpu.sp - headerSize] = cpu.mp;
cpu.mp = cpu.sp;
cpu.sp -= headerSize;
}
break;
case PVM.call: // call function
if (mem[cpu.pc] < 0)
{
ps = badAdr;
}
else
{
mem[cpu.mp - 2] = cpu.fp;
mem[cpu.mp - 3] = cpu.pc + 1;
cpu.fp = cpu.mp;
cpu.pc = mem[cpu.pc];
}
break;
case PVM.retv: // return from void function
cpu.sp = cpu.fp;
cpu.mp = mem[cpu.fp - 4];
cpu.pc = mem[cpu.fp - 3];
cpu.fp = mem[cpu.fp - 2];
break;
default: // unrecognized opcode
ps = badOp;
break;
} // switch(cpu.ir)
} while (ps == running);
if (ps != finished)
{
PostMortem(results, pcNow);
}
TimeSpan ts = timer.Elapsed;
string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10);
Console.WriteLine("\n" + ops + " operations. Run Time " + elapsedTime);
timer.Reset();
timer.Stop();
} // PVM.Emulator
} // PVM.PostMortem
// The interpreters and utility methods
public static void Emulator(int initPC, int codeLen, int initSP,
InFile data, OutFile results, bool tracing,
bool traceStack, bool traceHeap)
{
// Emulates action of the codeLen instructions stored in mem[0 .. codeLen-1], with
// program counter initialized to initPC, stack pointer initialized to initSP.
// data and results are used for I/O. Tracing at the code level may be requested
int pcNow; // current program counter
int loop; // internal loops
int tos, sos; // value popped from stack
int adr;
stackBase = initSP;
heapBase = codeLen; // initialize boundaries
cpu.hp = heapBase; // initialize registers
cpu.sp = stackBase;
cpu.gp = stackBase;
cpu.mp = stackBase;
cpu.fp = stackBase;
cpu.pc = initPC; // initialize program counter
ps = running; // prepare to execute
int ops = 0;
timer.Start();
do
{
ops++;
pcNow = cpu.pc; // retain for tracing/postmortem
cpu.ir = mem[cpu.pc++]; // fetch
// if (tracing) Trace(results, pcNow, traceStack, traceHeap);
switch (cpu.ir)
{ // execute
case PVM.nop: // no operation
break;
case PVM.dsp: // decrement stack pointer (allocate space for variables)
cpu.sp -= mem[cpu.pc++];
break;
case PVM.ldc: // push constant value
mem[--cpu.sp] = mem[cpu.pc++];
break;
case PVM.lda: // push local address
mem[--cpu.sp] = cpu.fp - 1 - mem[cpu.pc++];
break;
case PVM.ldv: // dereference
mem[cpu.sp] = mem[mem[cpu.sp]];
break;
case PVM.sto: // store
tos = mem[cpu.sp++]; mem[mem[cpu.sp++]] = tos;
break;
case PVM.ldxa: // heap array indexing
tos = mem[cpu.sp++]; mem[cpu.sp] = mem[cpu.sp] + tos;
break;
case PVM.inpi: // integer input
mem[mem[cpu.sp++]] = data.ReadInt();
break;
case PVM.prni: // integer output
// if (tracing) results.Write(padding);
results.Write(mem[cpu.sp++], 0);
// if (tracing) results.WriteLine();
break;
case PVM.inpb: // boolean input
mem[mem[cpu.sp++]] = data.ReadBool() ? 1 : 0;
break;
case PVM.prnb: // boolean output
// if (tracing) results.Write(padding);
if (mem[cpu.sp++] != 0) results.Write(" true "); else results.Write(" false ");
// if (tracing) results.WriteLine();
break;
case PVM.prns: // string output
// if (tracing) results.Write(padding);
loop = mem[cpu.pc++];
while (mem[loop] != 0)
{
results.Write((char)mem[loop]); loop--;
}
// if (tracing) results.WriteLine();
break;
case PVM.prnl: // newline
results.WriteLine();
break;
case PVM.neg: // integer negation
mem[cpu.sp] = -mem[cpu.sp];
break;
case PVM.add: // integer addition
tos = mem[cpu.sp++]; mem[cpu.sp] += tos;
break;
case PVM.sub: // integer subtraction
tos = mem[cpu.sp++]; mem[cpu.sp] -= tos;
break;
case PVM.mul: // integer multiplication
tos = mem[cpu.sp++];
int temp = mem[cpu.sp];
int answer = temp * tos;
if (((tos > 0 && temp > 0) && answer < 0) || ((tos < 0 && temp < 0) && answer > 0) || ((tos > 0 || temp > 0) && answer < 0) || ((tos < 0 || temp < 0) && answer > 0) || answer > maxInt || answer < -maxInt)
{
PostMortem(results, pcNow);
break;
}
mem[cpu.sp] *= tos;
break;
case PVM.div: // integer division (quotient)
tos = mem[cpu.sp++];
if (tos == 0)
{
PostMortem(results, pcNow);
break;
}
mem[cpu.sp] /= tos;
break;
case PVM.rem: // integer division (remainder)
tos = mem[cpu.sp++]; mem[cpu.sp] %= tos;
break;
case PVM.not: // logical negation
mem[cpu.sp] = mem[cpu.sp] == 0 ? 1 : 0;
break;
case PVM.and: // logical and
tos = mem[cpu.sp++]; mem[cpu.sp] &= tos;
break;
case PVM.or: // logical or
tos = mem[cpu.sp++]; mem[cpu.sp] |= tos;
break;
case PVM.ceq: // logical equality
tos = mem[cpu.sp++]; mem[cpu.sp] = mem[cpu.sp] == tos ? 1 : 0;
break;
case PVM.cne: // logical inequality
tos = mem[cpu.sp++]; mem[cpu.sp] = mem[cpu.sp] != tos ? 1 : 0;
break;
case PVM.clt: // logical less
tos = mem[cpu.sp++]; mem[cpu.sp] = mem[cpu.sp] < tos ? 1 : 0;
break;
case PVM.cle: // logical less or equal
tos = mem[cpu.sp++]; mem[cpu.sp] = mem[cpu.sp] <= tos ? 1 : 0;
break;
case PVM.cgt: // logical greater
tos = mem[cpu.sp++]; mem[cpu.sp] = mem[cpu.sp] > tos ? 1 : 0;
break;
case PVM.cge: // logical greater or equal
tos = mem[cpu.sp++]; mem[cpu.sp] = mem[cpu.sp] >= tos ? 1 : 0;
break;
case PVM.brn: // unconditional branch
cpu.pc = mem[cpu.pc++];
break;
case PVM.bze: // pop top of stack, branch if false
int target = mem[cpu.pc++];
if (mem[cpu.sp++] == 0) cpu.pc = target;
break;
case PVM.anew: // heap array allocation
int size = mem[cpu.sp];
mem[cpu.sp] = cpu.hp;
cpu.hp += size;
break;
case PVM.halt: // halt
ps = finished;
break;
case PVM.stk: // stack dump (debugging)
StackDump(results, pcNow);
break;
case PVM.heap: // heap dump (debugging)
HeapDump(results, pcNow);
break;
case PVM.ldc_0: // push constant 0
mem[--cpu.sp] = 0;
break;
case PVM.ldc_1: // push constant 1
mem[--cpu.sp] = 1;
break;
case PVM.ldc_2: // push constant 2
mem[--cpu.sp] = 2;
break;
case PVM.ldc_3: // push constant 3
mem[--cpu.sp] = 3;
break;
case PVM.lda_0: // push local address 0
mem[--cpu.sp] = cpu.fp - mem[cpu.pc++];
break;
case PVM.lda_1: // push local address 1
mem[--cpu.sp] = cpu.fp -1 -mem[cpu.pc++];
break;
case PVM.lda_2: // push local address 2
mem[--cpu.sp] = cpu.fp -2- mem[cpu.pc++];
break;
case PVM.lda_3: // push local address 3
mem[--cpu.sp] = cpu.fp -3- mem[cpu.pc++];
break;
case PVM.ldl_0: // push value of local variable 0
mem[--cpu.sp] = cpu.fp - mem[cpu.pc++];
mem[cpu.sp] = mem[mem[cpu.sp]];
break;
case PVM.ldl_1: // push value of local variable 1
mem[--cpu.sp] = cpu.fp -1- mem[cpu.pc++];
mem[cpu.sp] = mem[mem[cpu.sp]];
break;
case PVM.ldl_2: // push value of local variable 2
mem[--cpu.sp] = cpu.fp -2- mem[cpu.pc++];
mem[cpu.sp] = mem[mem[cpu.sp]];
break;
case PVM.ldl_3: // push value of local variable 3
mem[--cpu.sp] = cpu.fp -3- mem[cpu.pc++];
mem[cpu.sp] = mem[mem[cpu.sp]];
break;
case PVM.stl: // store local value
// we have bug here with PushPop, test here shows:
adr = cpu.fp - 1 - mem[cpu.pc++];
mem[cpu.sp++] = mem[adr];
break;
case PVM.stl_0: // pop to local variable 0
mem[cpu.sp] = mem[mem[cpu.sp]];
mem[--cpu.sp] = cpu.fp - mem[cpu.pc++];
break;
case PVM.stl_1: // pop to local variable 1
mem[cpu.sp] = mem[mem[cpu.sp]];
mem[--cpu.sp] = cpu.fp -1- mem[cpu.pc++];
break;
case PVM.stl_2: // pop to local variable 2
mem[cpu.sp] = mem[mem[cpu.sp]];
mem[--cpu.sp] = cpu.fp -2- mem[cpu.pc++];
break;
case PVM.stl_3: // pop to local variable 3
mem[cpu.sp] = mem[mem[cpu.sp]];
mem[--cpu.sp] = cpu.fp -3-mem[cpu.pc++];
break;
case PVM.inpc: // character input
var line = data.ReadLine();
char tempChar = string.IsNullOrEmpty(line) ? ' ' : line[0];
mem[cpu.sp++] = tempChar;
if (data.Error()) ps = badData;
break;
case PVM.prnc: // character output
if (tracing) results.WriteLine(padding);
int readIn = mem[mem[cpu.sp++]];
results.WriteLine((char)readIn);
if (tracing) results.WriteLine();
break;
case PVM.cap: // toUpperCase
int cUp = mem[cpu.sp++];
cUp = (int)char.ToUpper((char)cUp);
mem[cpu.sp++] = cUp;
break;
case PVM.low: // toLowerCase
int cLow = mem[cpu.sp++];
cLow = (int)char.ToLower((char)cLow);
mem[cpu.sp++] = cLow;
break;
case PVM.islet: // isLetter
int val = mem[mem[cpu.sp]];
results.WriteLine("Character readIn: " + ((char)val).ToString());
if (Char.IsLetter((char)val)) mem[cpu.sp] = 1; else mem[cpu.sp] = 0;
break;
case PVM.inc: // ++
int inc_a = mem[cpu.sp++] + 1;
mem[cpu.sp++] = inc_a;
break;
case PVM.dec: // --
int dec_a = mem[cpu.sp++] - 1;
mem[cpu.sp++] = dec_a;
break;
case PVM.ldl: // push local value
mem[--cpu.sp] = mem[cpu.pc++];
var N = mem[cpu.sp];
mem[--cpu.sp] = cpu.fp - 1 - N;
mem[cpu.sp] = mem[mem[cpu.sp]];
break;
case PVM.stlc: // store local value
tos = mem[cpu.sp++]; mem[mem[cpu.sp++]] = tos;
break;
case PVM.stoc: // character checked store
default: // unrecognized opcode
ps = badOp;
break;
}
} while (ps == running);
TimeSpan ts = timer.Elapsed;
// Format and display the TimeSpan value.
string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10);
Console.WriteLine("\n\n" + ops + " operations. Run Time " + elapsedTime + "\n\n");
if (ps != finished) PostMortem(results, pcNow);
timer.Reset();
timer.Stop();
} // PVM.Emulator
} // PVM.InBounds
public static void Emulator(int initPC, int codeLen, int initSP,
InFile data, OutFile results, bool tracing,
bool traceStack, bool traceHeap) {
// Emulates action of the codeLen instructions stored in mem[0 .. codeLen-1], with
// program counter initialized to initPC, stack pointer initialized to initSP.
// data and results are used for I/O. Tracing at the code level may be requested
int pcNow; // current program counter
int loop; // internal loops
int tos, sos; // values popped from stack
int adr; // effective address for memory accesses
int target; // destination for branches
stackBase = initSP;
heapBase = codeLen; // initialize boundaries
cpu.hp = heapBase; // initialize registers
cpu.sp = stackBase;
cpu.gp = stackBase;
cpu.mp = stackBase;
cpu.fp = stackBase;
cpu.pc = initPC; // initialize program counter
for (int i = heapBase; i < stackBase; i++)
mem[i] = 0; // set entire memory to null or 0
ps = running; // prepare to execute
int ops = 0;
timer.Start();
do {
ops++;
pcNow = cpu.pc; // retain for tracing/postmortem
if (cpu.pc < 0 || cpu.pc >= codeLen) {
ps = badAdr;
break;
}
cpu.ir = Next(); // fetch
if (tracing) Trace(results, pcNow, traceStack, traceHeap);
switch (cpu.ir) { // execute
case PVM.nop: // no operation
break;
case PVM.dsp: // decrement stack pointer (allocate space for variables)
int localSpace = Next();
cpu.sp -= localSpace;
if (InBounds(cpu.sp)) // initialize all local variables to zero/null
for (loop = 0; loop < localSpace; loop++)
mem[cpu.sp + loop] = 0;
break;
case PVM.ldc: // push constant value
Push(Next());
break;
case PVM.ldc_m1: // push constant -1
Push(-1);
break;
case PVM.ldc_0: // push constant 0
Push(0);
break;
case PVM.ldc_1: // push constant 1
Push(1);
break;
case PVM.ldc_2: // push constant 2
Push(2);
break;
case PVM.ldc_3: // push constant 3
Push(3);
break;
case PVM.ldc_4: // push constant 4
Push(4);
break;
case PVM.ldc_5: // push constant 5
Push(5);
break;
case PVM.dup: // duplicate top of stack
tos = Pop();
Push(tos); Push(tos);
break;
case PVM.lda: // push local address
adr = cpu.fp - 1 - Next();
if (InBounds(adr)) Push(adr);
break;
case PVM.lda_0: // push local address 0
adr = cpu.fp - 1;
if (InBounds(adr)) Push(adr);
break;
case PVM.lda_1: // push local address 1
adr = cpu.fp - 2;
if (InBounds(adr)) Push(adr);
break;
case PVM.lda_2: // push local address 2
adr = cpu.fp - 3;
if (InBounds(adr)) Push(adr);
break;
case PVM.lda_3: // push local address 3
adr = cpu.fp - 4;
if (InBounds(adr)) Push(adr);
break;
case PVM.lda_4: // push local address 4
adr = cpu.fp - 5;
if (InBounds(adr)) Push(adr);
break;
case PVM.lda_5: // push local address 5
adr = cpu.fp - 6;
if (InBounds(adr)) Push(adr);
break;
case PVM.ldl: // push local value
adr = cpu.fp - 1 - Next();
if (InBounds(adr)) Push(mem[adr]);
break;
case PVM.ldl_0: // push value of local variable 0
adr = cpu.fp - 1;
if (InBounds(adr)) Push(mem[adr]);
break;
case PVM.ldl_1: // push value of local variable 1
adr = cpu.fp - 2;
if (InBounds(adr)) Push(mem[adr]);
break;
case PVM.ldl_2: // push value of local variable 2
adr = cpu.fp - 3;
if (InBounds(adr)) Push(mem[adr]);
break;
case PVM.ldl_3: // push value of local variable 3
adr = cpu.fp - 4;
if (InBounds(adr)) Push(mem[adr]);
break;
case PVM.ldl_4: // push value of local variable 4
adr = cpu.fp - 5;
if (InBounds(adr)) Push(mem[adr]);
break;
case PVM.ldl_5: // push value of local variable 5
adr = cpu.fp - 6;
if (InBounds(adr)) Push(mem[adr]);
break;
case PVM.stl: // store local value
adr = cpu.fp - 1 - Next();
if (InBounds(adr)) mem[adr] = Pop();
break;
case PVM.stlc: // character checked pop to local variable
tos = Pop(); adr = cpu.fp - 1 - Next();
if (InBounds(adr))
if (tos >= 0 && tos <= maxChar) mem[adr] = tos;
else ps = badVal;
break;
case PVM.stl_0: // pop to local variable 0
adr = cpu.fp - 1;
if (InBounds(adr)) mem[adr] = Pop();
break;
case PVM.stl_1: // pop to local variable 1
adr = cpu.fp - 2;
if (InBounds(adr)) mem[adr] = Pop();
break;
case PVM.stl_2: // pop to local variable 2
adr = cpu.fp - 3;
if (InBounds(adr)) mem[adr] = Pop();
break;
case PVM.stl_3: // pop to local variable 3
adr = cpu.fp - 4;
if (InBounds(adr)) mem[adr] = Pop();
break;
case PVM.stl_4: // pop to local variable 4
adr = cpu.fp - 5;
if (InBounds(adr)) mem[adr] = Pop();
break;
case PVM.stl_5: // pop to local variable 5
adr = cpu.fp - 6;
if (InBounds(adr)) mem[adr] = Pop();
break;
case PVM.ldv: // dereference
adr = Pop();
if (InBounds(adr)) Push(mem[adr]);
break;
case PVM.sto: // store
tos = Pop(); adr = Pop();
if (InBounds(adr)) mem[adr] = tos;
break;
case PVM.stoc: // character checked store
tos = Pop(); adr = Pop();
if (InBounds(adr))
if (tos >= 0 && tos <= maxChar) mem[adr] = tos;
else ps = badVal;
break;
case PVM.ldxa: // heap array indexing
adr = Pop();
int heapPtr = Pop();
if (heapPtr == 0) ps = nullRef;
else if (heapPtr < heapBase || heapPtr >= cpu.hp) ps = badMem;
else if (adr < 0 || adr >= mem[heapPtr]) ps = badInd;
else Push(heapPtr + adr + 1);
break;
case PVM.inpi: // integer input
adr = Pop();
if (InBounds(adr)) {
mem[adr] = data.ReadInt();
if (data.Error()) ps = badData;
}
break;
case PVM.inpb: // boolean input
adr = Pop();
if (InBounds(adr)) {
mem[adr] = data.ReadBool() ? 1 : 0;
if (data.Error()) ps = badData;
}
break;
case PVM.inpc: // character input
adr = Pop();
if (InBounds(adr)) {
mem[adr] = data.ReadChar();
if (data.Error()) ps = badData;
}
break;
case PVM.inpl: // skip to end of input line
data.ReadLine();
break;
case PVM.i2c: // check (char) cast is in range
if (mem[cpu.sp] < 0 || mem[cpu.sp] > maxChar) ps = badVal;
break;
case PVM.prni: // integer output
if (tracing) results.Write(padding);
results.Write(Pop(), 0);
if (tracing) results.WriteLine();
break;
case PVM.prnb: // boolean output
if (tracing) results.Write(padding);
if (Pop() != 0) results.Write(" true "); else results.Write(" false ");
if (tracing) results.WriteLine();
break;
case PVM.prnc: // character output
if (tracing) results.Write(padding);
results.Write((char) (Math.Abs(Pop()) % (maxChar + 1)), 1);
if (tracing) results.WriteLine();
break;
case PVM.prns: // string output
if (tracing) results.Write(padding);
loop = Next();
while (ps == running && mem[loop] != 0) {
results.Write((char) mem[loop]); loop--;
if (loop < stackBase) ps = badMem;
}
if (tracing) results.WriteLine();
break;
case PVM.prnl: // newline
results.WriteLine();
break;
case PVM.neg: // integer negation
Push(-Pop());
break;
case PVM.add: // integer addition
tos = Pop(); Push(Pop() + tos);
break;
case PVM.sub: // integer subtraction
tos = Pop(); Push(Pop() - tos);
break;
case PVM.mul: // integer multiplication
tos = Pop();
sos = Pop();
if (tos != 0 && Math.Abs(sos) > maxInt / Math.Abs(tos)) ps = badVal;
else Push(sos * tos);
break;
case PVM.div: // integer division (quotient)
tos = Pop();
if (tos == 0) ps = divZero;
else Push(Pop() / tos);
break;
case PVM.rem: // integer division (remainder)
tos = Pop();
if (tos == 0) ps = divZero;
else Push(Pop() % tos);
break;
case PVM.not: // logical negation
Push(Pop() == 0 ? 1 : 0);
break;
case PVM.and: // logical and
tos = Pop(); Push(Pop() & tos);
break;
case PVM.or: // logical or
tos = Pop(); Push(Pop() | tos);
break;
case PVM.ceq: // logical equality
tos = Pop(); Push(Pop() == tos ? 1 : 0);
break;
case PVM.cne: // logical inequality
tos = Pop(); Push(Pop() != tos ? 1 : 0);
break;
case PVM.clt: // logical less
tos = Pop(); Push(Pop() < tos ? 1 : 0);
break;
case PVM.cle: // logical less or equal
tos = Pop(); Push(Pop() <= tos ? 1 : 0);
break;
case PVM.cgt: // logical greater
tos = Pop(); Push(Pop() > tos ? 1 : 0);
break;
case PVM.cge: // logical greater or equal
tos = Pop(); Push(Pop() >= tos ? 1 : 0);
break;
case PVM.brn: // unconditional branch
cpu.pc = Next();
if (cpu.pc < 0 || cpu.pc >= codeLen) ps = badAdr;
break;
case PVM.bze: // pop top of stack, branch if false
target = Next();
if (Pop() == 0) {
cpu.pc = target;
if (cpu.pc < 0 || cpu.pc >= codeLen) ps = badAdr;
}
break;
case PVM.bfalse: // conditional short circuit "and" branch
target = Next();
if (mem[cpu.sp] == 0) cpu.pc = target; else cpu.sp++;
break;
case PVM.btrue: // conditional short circuit "or" branch
target = Next();
if (mem[cpu.sp] == 1) cpu.pc = target; else cpu.sp++;
break;
case PVM.anew: // heap array allocation
int size = Pop();
if (size <= 0 || size + 1 > cpu.sp - cpu.hp - 2)
ps = badAll;
else {
mem[cpu.hp] = size; // first element stores size for bounds checking
Push(cpu.hp);
cpu.hp += size + 1; // bump heap pointer
// elements are already initialized to 0 / null (why?)
}
break;
case PVM.halt: // halt
ps = finished;
break;
case PVM.inc: // integer ++
adr = Pop();
if (InBounds(adr)) mem[adr]++;
break;
case PVM.dec: // integer --
adr = Pop();
if (InBounds(adr)) mem[adr]--;
break;
case PVM.incc: // ++ characters
adr = Pop();
if (InBounds(adr))
if (mem[adr] < maxChar) mem[adr]++;
else ps = badVal;
break;
case PVM.decc: // -- characters
adr = Pop();
if (InBounds(adr))
if (mem[adr] > 0) mem[adr]--;
else ps = badVal;
break;
case PVM.stack: // stack dump (debugging)
StackDump(results, pcNow);
break;
case PVM.heap: // heap dump (debugging)
HeapDump(results, pcNow);
break;
case PVM.fhdr: // allocate frame header
if (InBounds(cpu.sp - headerSize)) {
mem[cpu.sp - headerSize] = cpu.mp;
cpu.mp = cpu.sp;
cpu.sp -= headerSize;
}
break;
case PVM.call: // call function
if (mem[cpu.pc] < 0) ps = badAdr;
else {
mem[cpu.mp - 2] = cpu.fp;
mem[cpu.mp - 3] = cpu.pc + 1;
cpu.fp = cpu.mp;
cpu.pc = mem[cpu.pc];
}
break;
case PVM.retv: // return from void function
cpu.sp = cpu.fp;
cpu.mp = mem[cpu.fp - 4];
cpu.pc = mem[cpu.fp - 3];
cpu.fp = mem[cpu.fp - 2];
break;
case PVM.max:
tos = Pop();
sos = Pop();
if (tos > sos) Push(tos);
else Push(sos);
break;
case PVM.min:
tos = Pop();
sos = Pop();
if (tos < sos) Push(tos);
else Push(sos);
break;
case PVM.sqr:
tos = Pop();
Push((int)Math.Sqrt(tos));
break;
case PVM.aceq:
tos =Pop(); //address of array 1
sos = Pop(); //address of array 1
int len_1 = mem[tos];
int len_2 = mem[sos];
if(len_1!=len_2){
Push(0); // if lengths aren't equal then arrays can't be equal
}
else{
int i=0;
while(i<len_1 && mem[tos+1+i] == mem[sos+1+i]){
i++;
}
if(i==len_1)
Push(1);
else
Push(0);
}
break;
case PVM.acpy:
tos =Pop(); //address to be copied
sos = Pop(); //address of array to be assigned
if(mem[tos]==mem[sos]){ //if the lengths are not the same leave it
int i=0;
while(i<mem[tos]){
mem[sos+1+i] = mem[tos+1+i];
}
}
/*
else{
IO.WriteLine("Arrays must be the same size to be copied!");
ps=badVal;
}
*/
break;
case PVM.wprni: // integer output with wdith
if (tracing) results.Write(padding);
tos=Pop();
results.Write(Pop(),tos);
if (tracing) results.WriteLine();
break;
case PVM.wprnb: // boolean output with width
if (tracing) results.Write(padding);
tos = Pop();
if (Pop() != 0) results.Write("true",tos); else results.Write("false",tos);
if (tracing) results.WriteLine();
break;
case PVM.wprnc: // character output with width
if (tracing) results.Write(padding);
tos = Pop();
results.Write((char) (Math.Abs(Pop()) % (maxChar + 1)), tos);
if (tracing) results.WriteLine();
break;
default: // unrecognized opcode
ps = badOp;
break;
} // switch(cpu.ir)
} while (ps == running);
if (ps != finished) PostMortem(results, pcNow);
TimeSpan ts = timer.Elapsed;
string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10);
Console.WriteLine("\n" + ops + " operations. Run Time " + elapsedTime);
timer.Reset();
timer.Stop();
} // PVM.Emulator
} // PVM.InBounds
public static void Emulator(int initPC, int codeLen, int initSP,
InFile data, OutFile results, bool tracing,
bool traceStack, bool traceHeap)
{
// Emulates action of the codeLen instructions stored in mem[0 .. codeLen-1], with
// program counter initialized to initPC, stack pointer initialized to initSP.
// data and results are used for I/O. Tracing at the code level may be requested
int pcNow; // current program counter
int loop; // internal loops
int tos, sos; // values popped from stack
int adr; // effective address for memory accesses
int target; // destination for
int store = 0; // saves the next location of
int store2 = 0; // compares
stackBase = initSP;
heapBase = codeLen; // initialize boundaries
cpu.hp = heapBase; // initialize registers
cpu.sp = stackBase;
cpu.gp = stackBase;
cpu.mp = stackBase;
cpu.fp = stackBase;
cpu.pc = initPC; // initialize program counter
for (int i = heapBase; i < stackBase; i++)
{
mem[i] = 0; // set entire memory to null or 0
}
ps = running; // prepare to execute
int ops = 0;
timer.Start();
do
{
ops++;
pcNow = cpu.pc; // retain for tracing/postmortem
if (cpu.pc < 0 || cpu.pc >= codeLen)
{
ps = badAdr;
break;
}
cpu.ir = Next(); // fetch
if (tracing)
{
Trace(results, pcNow, traceStack, traceHeap);
}
switch (cpu.ir) // execute
{
case PVM.nop: // no operation
break;
case PVM.dsp: // decrement stack pointer (allocate space for variables)
int localSpace = Next();
cpu.sp -= localSpace;
if (InBounds(cpu.sp)) // initialize all local variables to zero/null
{
for (loop = 0; loop < localSpace; loop++)
{
mem[cpu.sp + loop] = 0;
}
}
break;
case PVM.ldc: // push constant value
Push(Next());
break;
case PVM.ldc_m1: // push constant -1
Push(-1);
break;
case PVM.ldc_0: // push constant 0
Push(0);
break;
case PVM.ldc_1: // push constant 1
Push(1);
break;
case PVM.ldc_2: // push constant 2
Push(2);
break;
case PVM.ldc_3: // push constant 3
Push(3);
break;
case PVM.ldc_4: // push constant 4
Push(4);
break;
case PVM.ldc_5: // push constant 5
Push(5);
break;
case PVM.lda: // push local address
adr = cpu.fp - 1 - Next();
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.lda_0: // push local address 0
adr = cpu.fp - 1;
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.lda_1: // push local address 1
adr = cpu.fp - 2;
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.lda_2: // push local address 2
adr = cpu.fp - 3;
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.lda_3: // push local address 3
adr = cpu.fp - 4;
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.lda_4: // push local address 4
adr = cpu.fp - 5;
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.lda_5: // push local address 5
adr = cpu.fp - 6;
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.ldga: // push global address
adr = cpu.gp - 1 - Next();
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.ldg_0: // push local address 0
adr = cpu.gp - 1;
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.ldg_1: // push local address 1
adr = cpu.gp - 2;
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.ldg_2: // push local address 2
adr = cpu.gp - 3;
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.ldg_3: // push local address 3
adr = cpu.gp - 4;
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.ldg_4: // push local address 4
adr = cpu.gp - 5;
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.ldg_5: // push local address 5
adr = cpu.gp - 6;
if (InBounds(adr))
{
Push(adr);
}
break;
case PVM.ldl: // push local value
adr = cpu.fp - 1 - Next();
if (InBounds(adr))
{
Push(mem[adr]);
}
break;
case PVM.ldl_0: // push value of local variable 0
adr = cpu.fp - 1;
if (InBounds(adr))
{
Push(mem[adr]);
}
break;
case PVM.ldl_1: // push value of local variable 1
adr = cpu.fp - 2;
if (InBounds(adr))
{
Push(mem[adr]);
}
break;
case PVM.ldl_2: // push value of local variable 2
adr = cpu.fp - 3;
if (InBounds(adr))
{
Push(mem[adr]);
}
break;
case PVM.ldl_3: // push value of local variable 3
adr = cpu.fp - 4;
if (InBounds(adr))
{
Push(mem[adr]);
}
break;
case PVM.ldl_4: // push value of local variable 4
adr = cpu.fp - 5;
if (InBounds(adr))
{
Push(mem[adr]);
}
break;
case PVM.ldl_5: // push value of local variable 5
adr = cpu.fp - 6;
if (InBounds(adr))
{
Push(mem[adr]);
}
break;
case PVM.stl: // store local value
adr = cpu.fp - 1 - Next();
if (InBounds(adr))
{
mem[adr] = Pop();
}
break;
case PVM.stlc: // character checked pop to local variable
tos = Pop(); adr = cpu.fp - 1 - Next();
if (InBounds(adr))
{
if (tos >= 0 && tos <= maxChar)
{
mem[adr] = tos;
}
else
{
ps = badVal;
}
}
break;
case PVM.stl_0: // pop to local variable 0
adr = cpu.fp - 1;
if (InBounds(adr))
{
mem[adr] = Pop();
}
break;
case PVM.stl_1: // pop to local variable 1
adr = cpu.fp - 2;
if (InBounds(adr))
{
mem[adr] = Pop();
}
break;
case PVM.stl_2: // pop to local variable 2
adr = cpu.fp - 3;
if (InBounds(adr))
{
mem[adr] = Pop();
}
break;
case PVM.stl_3: // pop to local variable 3
adr = cpu.fp - 4;
if (InBounds(adr))
{
mem[adr] = Pop();
}
break;
case PVM.stl_4: // pop to local variable 4
adr = cpu.fp - 5;
if (InBounds(adr))
{
mem[adr] = Pop();
}
break;
case PVM.stl_5: // pop to local variable 5
adr = cpu.fp - 6;
if (InBounds(adr))
{
mem[adr] = Pop();
}
break;
case PVM.ldv: // dereference
adr = Pop();
if (InBounds(adr))
{
Push(mem[adr]);
}
break;
case PVM.sto: // store
tos = Pop(); adr = Pop();
if (InBounds(adr))
{
mem[adr] = tos;
}
break;
case PVM.stoc: // character checked store
tos = Pop(); adr = Pop();
if (InBounds(adr))
{
if (tos >= 0 && tos <= maxChar)
{
mem[adr] = tos;
}
else
{
ps = badVal;
}
}
break;
case PVM.ldxa: // heap array indexing
adr = Pop();
int heapPtr = Pop();
if (heapPtr == 0)
{
ps = nullRef;
}
else if (heapPtr < heapBase || heapPtr >= cpu.hp)
{
ps = badMem;
}
else if (adr < 0 || adr >= mem[heapPtr])
{
ps = badInd;
}
else
{
Push(heapPtr + adr + 1);
}
break;
case PVM.inpi: // integer input
adr = Pop();
if (InBounds(adr))
{
mem[adr] = data.ReadInt();
if (data.Error())
{
ps = badData;
}
}
break;
case PVM.inpb: // boolean input
adr = Pop();
if (InBounds(adr))
{
mem[adr] = data.ReadBool() ? 1 : 0;
if (data.Error())
{
ps = badData;
}
}
break;
case PVM.inpc: // character input
adr = Pop();
if (InBounds(adr))
{
mem[adr] = data.ReadChar();
if (data.Error())
{
ps = badData;
}
}
break;
case PVM.inpl: // skip to end of input line
data.ReadLine();
break;
case PVM.i2c: // check convert character to integer
if (mem[cpu.sp] < 0 || mem[cpu.sp] > maxChar)
{
ps = badVal;
}
else
{
Push((int)Pop());
}
break;
case PVM.c2i: // check convert integer to
adr = Pop();
if ((adr >= 65 && adr <= 90) || (adr >= 97 && adr <= 122))
{
Push((char)adr);
}
else
{
ps = badCast;
}
break;
case PVM.prni: // integer output
if (tracing)
{
results.Write(padding);
}
results.Write(Pop(), 0);
if (tracing)
{
results.WriteLine();
}
break;
case PVM.prnb: // boolean output
if (tracing)
{
results.Write(padding);
}
if (Pop() != 0)
{
results.Write(" true ");
}
else
{
results.Write(" false ");
}
if (tracing)
{
results.WriteLine();
}
break;
case PVM.prnc: // character output
if (tracing)
{
results.Write(padding);
}
results.Write((char)(Math.Abs(Pop()) % (maxChar + 1)), 1);
if (tracing)
{
results.WriteLine();
}
break;
case PVM.prns: // string output
if (tracing)
{
results.Write(padding);
}
loop = Next();
while (ps == running && mem[loop] != 0)
{
results.Write((char)mem[loop]); loop--;
if (loop < stackBase)
{
ps = badMem;
}
}
if (tracing)
{
results.WriteLine();
}
break;
case PVM.prnl: // newline
results.WriteLine();
break;
case PVM.neg: // integer negation
Push(-Pop());
break;
case PVM.add: // integer addition
tos = Pop(); Push(Pop() + tos);
break;
case PVM.sub: // integer subtraction
tos = Pop(); Push(Pop() - tos);
break;
case PVM.mul: // integer multiplication
tos = Pop();
sos = Pop();
if (tos != 0 && Math.Abs(sos) > maxInt / Math.Abs(tos))
{
ps = badVal;
}
else
{
Push(sos * tos);
}
break;
case PVM.div: // integer division (quotient)
tos = Pop();
if (tos == 0)
{
ps = divZero;
}
else
{
Push(Pop() / tos);
}
break;
case PVM.rem: // integer division (remainder)
tos = Pop();
if (tos == 0)
{
ps = divZero;
}
else
{
Push(Pop() % tos);
}
break;
case PVM.not: // logical negation
Push(Pop() == 0 ? 1 : 0);
break;
case PVM.and: // logical and
tos = Pop(); Push(Pop() & tos);
break;
case PVM.or: // logical or
tos = Pop(); Push(Pop() | tos);
break;
case PVM.ceq: // logical equality
tos = Pop(); Push(Pop() == tos ? 1 : 0);
break;
case PVM.cne: // logical inequality
tos = Pop(); Push(Pop() != tos ? 1 : 0);
break;
case PVM.clt: // logical less
tos = Pop(); Push(Pop() < tos ? 1 : 0);
break;
case PVM.cle: // logical less or equal
tos = Pop(); Push(Pop() <= tos ? 1 : 0);
break;
case PVM.cgt: // logical greater
tos = Pop(); Push(Pop() > tos ? 1 : 0);
break;
case PVM.cge: // logical greater or equal
tos = Pop(); Push(Pop() >= tos ? 1 : 0);
break;
case PVM.brn: // unconditional branch
store = cpu.pc + 1;
store2 = Next();
cpu.pc = store2;
if (cpu.pc < 0 || cpu.pc >= codeLen)
{
ps = badAdr;
}
break;
case PVM.bze: // pop top of stack, branch if false
target = Next();
if (Pop() == 0)
{
cpu.pc = target;
if (cpu.pc < 0 || cpu.pc >= codeLen)
{
ps = badAdr;
}
}
break;
case PVM.pjp: // jumps to the location of given parameter
if (store == store2)
{
cpu.pc++;
}
else
{
cpu.pc = store;
}
if (cpu.pc < 0 || cpu.pc >= codeLen)
{
ps = badAdr;
}
break;
case PVM.bfalse: // conditional short circuit "and" branch
target = Next();
if (mem[cpu.sp] == 0)
{
cpu.pc = target;
}
else
{
cpu.sp++;
}
break;
case PVM.btrue: // conditional short circuit "or" branch
target = Next();
if (mem[cpu.sp] == 1)
{
cpu.pc = target;
}
else
{
cpu.sp++;
}
break;
case PVM.anew: // heap array allocation
int size = Pop();
if (size <= 0 || size + 1 > cpu.sp - cpu.hp - 2)
{
ps = badAll;
}
else
{
mem[cpu.hp] = size; // first element stores size for bounds checking
Push(cpu.hp);
cpu.hp += size + 1; // bump heap pointer
// elements are already initialized to 0 / null (why?)
}
break;
case PVM.halt: // halt
ps = finished;
break;
case PVM.inc: // integer ++
adr = Pop();
if (InBounds(adr))
{
mem[adr]++;
}
break;
case PVM.dec: // integer --
adr = Pop();
if (InBounds(adr))
{
mem[adr]--;
}
break;
case PVM.incc: // ++ characters
adr = Pop();
if (InBounds(adr))
{
if (mem[adr] < maxChar)
{
mem[adr]++;
}
else
{
ps = badVal;
}
}
break;
case PVM.decc: // -- characters
adr = Pop();
if (mem[adr] > 0)
{
mem[adr]--;
}
else
{
ps = badVal;
}
break;
case PVM.stack: // stack dump (debugging)
StackDump(results, pcNow);
break;
case PVM.heap: // heap dump (debugging)
HeapDump(results, pcNow);
break;
case PVM.fhdr: // allocate frame header
if (InBounds(cpu.sp - headerSize))
{
mem[cpu.sp - headerSize] = cpu.mp;
cpu.mp = cpu.sp;
cpu.sp -= headerSize;
}
break;
case PVM.call: // call function
if (mem[cpu.pc] < 0)
{
ps = badAdr;
}
else
{
mem[cpu.mp - 2] = cpu.fp;
mem[cpu.mp - 3] = cpu.pc + 1;
cpu.fp = cpu.mp;
cpu.pc = mem[cpu.pc];
}
break;
case PVM.retv: // return from void function
cpu.sp = cpu.fp;
cpu.mp = mem[cpu.fp - 4];
cpu.pc = mem[cpu.fp - 3];
cpu.fp = mem[cpu.fp - 2];
break;
case PVM.ret: // return from non-void function
cpu.sp = cpu.fp - 1;
cpu.mp = mem[cpu.fp - 4];
cpu.pc = mem[cpu.fp - 3];
cpu.fp = mem[cpu.fp - 2];
break;
case PVM.trap: // trap falling off end of function
ps = badFun;
break;
case PVM.low: // toLowerCase
Push(Char.ToLower((char)Pop()));
break;
case PVM.cap: // toUpperCase
Push(Char.ToUpper((char)Pop()));
break;
case PVM.islet: // isLetter
tos = Pop();
Push(Char.IsLetter((char)tos) ? 1 : 0);
break;
case PVM.pop: // pop and discard tos
tos = Pop();
break;
case PVM.dup: // duplicate tos
tos = Pop();
Push(tos); Push(tos);
break;
default: // unrecognized opcode
ps = badOp;
break;
}
} while (ps == running);
TimeSpan ts = timer.Elapsed;
// Format and display the TimeSpan value.
string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10);
Console.WriteLine("\n\n" + ops + " operations. Run Time " + elapsedTime + "\n\n");
if (ps != finished)
{
PostMortem(results, pcNow);
}
timer.Reset();
timer.Stop();
} // PVM.Emulator
/// <summary>
/// Main program
/// </summary>
private static void Main(string[] args)
{
int[,] board = new int[9, 9];
// Check if a file input is specified
if (args.Length == 0)
{
//some input will be one of the solution files e.g s1
IO.WriteLine("Nothing was specified for input, rather used \"SudokuPrac1Question12.exe <some input>\"");
IO.ReadLine();
return;
}
// Load the file
InFile file = new InFile(args[0]);
string[] file_lines = new string[21];
int file_line_count = 0;
while (!file.EOF())
{
file_lines[file_line_count] = file.ReadLine();
file_line_count++;
}
// Interpret starting board: first 9 lines
for (int i = 0; i < 9; i++)
{
var points = file_lines[i].Split(" ".ToCharArray(), System.StringSplitOptions.RemoveEmptyEntries);
for (int j = 0; j < 9; j++)
{
board[j, i] = int.Parse(points[j]);
}
}
// Initiate the board
CreatePositionPoints();
CreatePlanningBoard(board);
bool not_complete = true, endGame = false;
int pos_x = 0, pos_y = 0, pos_choice = 0, value_count = 1;
int[,] ai_chosen_spots = new int[9, 9];
//main game loop
while (not_complete && !endGame)
{
Console.Clear();
UpdateSuggestedMoves(board, ref planning_board);
for (int x = 0; x < 9; x++)
{
for (int y = 0; y < 9; y++)
{
ai_chosen_spots[x, y] = 0;
}
}
DrawPlanningBoard();
int knownCount = 0;
for (int x = 0; x < 9; x++)
{
for (int y = 0; y < 9; y++)
{
if (board[x, y] != 0)
{
knownCount++;
}
}
}
AIGenerateChoices(ref ai_chosen_spots, board, StringPositions);
//Predicate<int> pre = delegate (int a) { return a == 0; };
int predictionCount = 0;
for (int x = 0; x < 9; x++)
{
for (int y = 0; y < 9; y++)
{
if (ai_chosen_spots[x, y] != 0)
{
predictionCount++;
}
}
}
if (predictionCount != 0) // if we found an ai choice
{
DrawBoard(board, ai_chosen_spots);
IO.WriteLine(knownCount + " known " + predictionCount + " predicted\n");
// check if at least 1 is suggested
IO.WriteLine("I did these, so press <enter> once:");
IO.ReadLine();
/*if (playerinput=1){
* //AIFillIn();
* }
*/
}
else
{
DrawBoard(board);
GetPlayerInput(ref pos_x, ref pos_y, ref pos_choice, ref endGame);
if (IsValidMove(board, pos_x, pos_y, pos_choice))
{
PlaceMoveAtPos(ref board, pos_x, pos_y, pos_choice);
UpdateSuggestedMoves(board, ref planning_board);
}
else
{
IO.WriteLine("Move is not valid, please try a new one");
}
}
// board complete check
value_count = 0;
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
if (board[i, j] == 0)
{
++value_count;
}
}
}
if (value_count == 0)
{
IO.WriteLine("Game won!");
not_complete = false;
}
}
IO.ReadLine();
}