#include <vector>
#include <queue>
#include <string>
namespace ov {
using namespace std;
enum opts { // opts are pas-1 bits aftr last ram ptr (2**ras)-1 and can be w/r from prg
DEFAULT,
BUFOUT, // output from program in VM is always possible and no blocks
BUFIN, // input to program in VM is always possible and no blocks
BUFINCLR, // clears whatever is in the input buffer
BUFOUTCLR, // clears whatever is in the output buffer
OPTSLEN
}; // read those last bits with the COPY instruction with source/dest on last pointer
enum iobits {
INA, // input available, clear when read
IN, // input bit
OUTA, // output available, set when have output, cleared by VM when wrote
OUT, // output bit
IOLEN
};
enum instrs {
COPY,
NAND
};
struct instr { // deserializirana inštrukcija
unsigned int s = 0; // source
unsigned int d = 0; // destination
bool i = 0; // instruction
bool p = 0; // enobitni padding, lahko za metainštrukcije, pri COPY je že
}; // privzeto inicializiran na NOOP inštrukcijo
template<typename value_type, typename index_type, class Memory> class Mmu {
private:
class Cell {
private:
friend class Mmu;
Mmu & mmu;
index_type index;
Cell (Mmu & mmu, index_type index)
: mmu(mmu), index(index) {}
public:
operator value_type (void) {
return mmu.memory.peek(index);
}
value_type operator= (value_type value) {
mmu.memory.poke(index, value);
return value;
}
};
public:
Memory & memory;
Mmu (Memory & memory) : memory(memory) {}
Cell operator[] (index_type index) {
return Cell(*this, index);
}
value_type & operator() (index_type index) {
return memory.peek(index);
}
};
class Ov;
template<typename value_type, typename index_type> class Ram {
private:
public:
vector<value_type> storage;
Ov * ov;
value_type peek (index_type);
void poke(index_type, value_type);
Ram (Ov *);
};
/* v Program (memory) bi lahko uporabili metainštrukcije (tisti padding bit) v
* vsaki inštrukciji in v metainštrukcijah reprezentirali assembly org (lokacijo).
* s tem bi lahko imeli npr. 128 biten program counter in s tem zelo preproste jumpe,
* ne bi pa bilo treba narediti 2^128 vektorja in posledično binarne datoteke.
* Tak način bi bilo verjetno težko implementirati na dejanski strojni opremi,
* tukaj pa bi v enem passu čez cel deserializan program memory zaznali te org
* metainštrukcije in naredili neko tabelo oziroma prevajalnik program counterja
* v lokacijo v vektorju. problem je, da bi se morala prevajalska tabela vsakič znova
* regenerirati, ko spreminjamo program memory.
* */
template<typename value_type, typename index_type> class Program {
private:
public:
vector<value_type> storage;
Ov * ov;
value_type & peek (index_type addr) {
return storage[addr];
}
void poke (index_type addr, value_type val) {
storage[addr] = val;
}
Program (Ov *);
};
class Ov {
private:
public:
queue<bool> inbuf;
queue<bool> outbuf;
#define IS2RAS(is) ((is*8-2)/2)
class ras { // IS
private: // IT
public: // REALLY
unsigned short int & is; // THIS
operator unsigned short int (void) { // HARD
return IS2RAS(is); // TO
} // DEFINE
ras (class Ov * ov) : is(ov->is) {} // A
}; // GETTER
ras ras{this}; // FUNCTION
class rs {
private:
public:
unsigned short int & is;
operator unsigned int (void) {
return 1 << IS2RAS(is);
}
rs (class Ov * ov) : is(ov->is) {}
};
rs rs{this};
class ps {
private:
public:
unsigned short int & pas;
operator unsigned int (void) {
return 1 << pas;
}
ps (class Ov * ov) : pas(ov->pas) {}
};
ps ps{this};
unsigned short int is;
unsigned short int pas;
bool io[IOLEN];
bool opts[OPTSLEN];
unsigned int pc = 0; /* where the program starts --- at zero or where? */
Ram<bool, unsigned int> rstor{this};
Mmu<bool, unsigned int, class Ram<bool, unsigned int>> ram{rstor};
Program<struct instr, unsigned int> pstor{this};
Mmu<struct instr, unsigned, class Program<struct instr, unsigned>> pm{pstor};
Ov (unsigned short int is = 2, unsigned short int pas = 16)
: is(is), pas(pas) { // add bound checks
for (int i = 0; i < OPTSLEN; i++)
opts[i] = 0;
for (int i = 0; i < IOLEN; i++)
io[i] = 0;
}
void step (void);
bool out (void);
char outc (void);
void in (bool);
void inc (char);
struct instr deserialize (const char [sizeof(struct instr)]);
void deserialize (istream &, unsigned int);
string serialize (struct instr * i, unsigned int);
void pd (ostream &);
};
}
