272 lines
11 KiB
JavaScript
272 lines
11 KiB
JavaScript
/**
|
|
* Created by sbosse on 3/16/15.
|
|
*/
|
|
var Types = require('./afvm_types');
|
|
var Code = require('./afvm_code');
|
|
var Stack = require('./afvm_stack');
|
|
var Proc = require('./afvm_processor');
|
|
var Man = require('./afvm_manager');
|
|
var Dict = require('./afvm_dictionary');
|
|
var Que = require('./afvm_queue');
|
|
var Sch = require('./scheduler');
|
|
var Io = require('./io');
|
|
var Net = require('./network');
|
|
var sizeof = require('./sizeof')
|
|
var util = require('util')
|
|
|
|
/*-----------------------------------------
|
|
-- MEMORY:
|
|
-- CS: Code Segment
|
|
--
|
|
-- REGISTER SET:
|
|
--
|
|
-- 1. PROGRAM PROCESSING
|
|
--
|
|
-- >>> CF OR CS OFFSETS ?????
|
|
--
|
|
-- CP: Code Segment Pointer (0=this CS,1= CCS)
|
|
-- CF: Current Code Frame (CS offset)
|
|
-- LP: LUT Code Offset Register (CS offset)
|
|
-- IP: Instruction Code Pointer (CF offset)
|
|
-- IR: Instruction Register
|
|
--
|
|
-- 2. STACK PROCESSING
|
|
--
|
|
-- T : Top element of Data Stack
|
|
-- S : Second element of Data Stack
|
|
-- R: Top element of Return Stack
|
|
--
|
|
-----------------------------------------*/
|
|
|
|
var assert = function(condition, message) {
|
|
if (!condition)
|
|
throw Error("[afvm_vm]" + (typeof message !== "undefined" ? ": " + message : ""));
|
|
};
|
|
|
|
function Noop () {};
|
|
|
|
var VM = function (id,stack_size,code_size,word_size,lut_row_size,cs,manager) {
|
|
var con;
|
|
con=Sch.Context(id,this);
|
|
this.stack = new Stack.Stack(stack_size);
|
|
this.coding = new Code.Coding(word_size,false);
|
|
this.processor = new Proc.Processor(code_size,word_size,lut_row_size,manager,this.coding,cs);
|
|
this.manager=manager;
|
|
this.state = undefined;
|
|
this.id=id;
|
|
this.tq= new Que.TokenQueue('VM'+id);
|
|
this.context=con;
|
|
|
|
this.token=undefined;
|
|
this.break=false;
|
|
this.admin=false;
|
|
this.notify=false;
|
|
this.exception=false;
|
|
};
|
|
|
|
/*
|
|
** State Machine
|
|
*/
|
|
|
|
VM.prototype.init = function (self) {
|
|
console.log('[VM '+self.id+'] Init.');
|
|
};
|
|
|
|
VM.prototype.await = function (self) {
|
|
self.token=self.tq.Inq();
|
|
console.log('[VM '+self.id+'] Await. [blocked '+self.context.blocked+' token='+util.inspect(self.token)+']');
|
|
};
|
|
|
|
VM.prototype.setup = function (self) {
|
|
console.log('[VM '+self.id+'] Setup. [token '+util.inspect(self.token)+']');
|
|
self.break=false;self.admin=false;self.notify=false;self.exception=false;
|
|
self.processor.Enter(self.token);
|
|
if (self.token.tk_colour != Types.Token_colour.TK_SIGH) self.stack.Clear();
|
|
};
|
|
|
|
VM.prototype.execute = function (self) {
|
|
var icode, i,ipmon;
|
|
self.processor.CurrInstruction();
|
|
console.log('[VM '+self.id+'] Execu. [CF='+self.processor.CF+' IP='+self.processor.IP+' IR='+self.coding.Print(self.processor.IR)+']');
|
|
ip_mon = self.processor.IP;
|
|
|
|
if (self.processor.IR.ic == Types.Command.RD) {
|
|
icode = Types.Command.IN;
|
|
} else {
|
|
icode = self.processor.IR.ic;
|
|
}
|
|
switch (icode) {
|
|
case Types.Command.NOP: Noop(); self.processor.NextInstruction(1); break;
|
|
/*
|
|
** STACK
|
|
*/
|
|
case Types.Command.VAL: self.stack.Push(self.processor.IR.ia); self.processor.NextInstruction(1); break;
|
|
case Types.Command.ZERO: self.stack.Push(0); self.processor.NextInstruction(1); break;
|
|
case Types.Command.ONE: self.stack.Push(1); self.processor.NextInstruction(1); break;
|
|
case Types.Command.DUP: self.stack.Dup(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.DROP: self.stack.Drop(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.SWAP: self.stack.Swap(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.ROT: self.stack.Rot(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.PICK: self.stack.Pick(self.processor.IR.ia); self.processor.NextInstruction(1); break;
|
|
case Types.Command.SET: self.stack.Set(self.processor.IR.ia); self.processor.NextInstruction(1); break;
|
|
case Types.Command.RPICK: self.stack.Rpick(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.RSET: self.stack.Rset(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.TOR: self.stack.Tor(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.CLEAR: self.stack.Clear(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.FROMR: self.stack.Fromr(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.RANDOM:
|
|
self.processor.B = self.Pop(); /* max */ self.processor.A = self.pop(); /* min */
|
|
self.Push(Math.floor((Math.random() * self.processor.B) + self.processor.A));
|
|
self.processor.NextInstruction(1); break;
|
|
case Types.Command.STORE:
|
|
self.processor.Store(self.stack.S0,self.stack.S1,self.stack.S2);
|
|
self.stack.Dropn(3);
|
|
self.processor.NextInstruction(1); break;
|
|
case Types.Command.FETCH:
|
|
if (self.stack.S0 <0 && self.stack.S1 < 0) {
|
|
// System variables
|
|
if (self.stack.S0 == -1) self.stack.S1 = self.PRO.pro_gid;
|
|
else if (self.stack.S0 == -2) self.stack.S1 = self.PRO.pro_par;
|
|
else self.stack.S1 = 0;
|
|
}
|
|
else
|
|
self.processor.Fetch(self.stack.S0,self.stack.S1);
|
|
self.stack.Drop();
|
|
self.processor.NextInstruction(1); break;
|
|
case Types.Command.REF:
|
|
if (self.processor.IR.ia >= 0) {
|
|
self.stack.Push(self.processor.LutOff(self.processor.IR.ia));
|
|
self.stack.Push(self.processor.LutFrame(self.processor.IR.ia))
|
|
}
|
|
else {
|
|
// System variables --
|
|
self.stack.Push(self.processor.IR.ia);
|
|
self.stack.Push(self.processor.IR.ia)
|
|
};
|
|
self.processor.NextInstruction(1); break;
|
|
case Types.Command.VAR:
|
|
self.A = (self.processor.GetInstruction(1)).ia; // REF
|
|
self.B = (self.processor.GetInstruction(2)).ia; // SIZE
|
|
// SetLutFlag(A,R_VAR);
|
|
self.processor.SetLutOff(self.A,self.IP+3);
|
|
self.processor.SetLutFrame(self.A,self.CF);
|
|
self.processor.SetLutSec(self.A,self.B);
|
|
self.processor.NextInstruction(self.B+3); break;
|
|
case Types.Command.LUT:
|
|
self.B = (self.processor.GetInstruction(1)).ia; // SIZE
|
|
self.LP = self.CF+self.IP+2;
|
|
// Clear LUT
|
|
self.A = 0;
|
|
for (i=self.LP; i <=self.LP+self.B; i++) {
|
|
if ((self.A % 4) != 0) {
|
|
// Reset LUT columns 2 .. 4 to default values (0)
|
|
self.CS[i]=self.coding.ToCodeM(Command.DATA,0);
|
|
}
|
|
self.A = self.A + 1;
|
|
};
|
|
self.processor.NextInstruction(self.B+2); break;
|
|
case Types.Command.DEF:
|
|
self.A = (self.processor.GetInstruction(1)).ia; // REF
|
|
self.B = (self.processor.GetInstruction(2)).ia; // SIZE
|
|
// SetLutFlag(A,R_FUN);
|
|
self.processor.SetLutFrame(self.A,self.CF);
|
|
self.processor.SetLutOff(self.A,self.IP+3);
|
|
self.processor.NextInstruction(self.B+3); break;
|
|
/*
|
|
** -- ARITH --
|
|
*/
|
|
case Types.Command.ADD: self.stack.Add(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.SUB: self.stack.Sub(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.MUL: self.stack.Mul(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.DIV: self.stack.Div(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.MOD: self.stack.Mod(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.NEG: self.stack.Neg(); self.processor.NextInstruction(1); break;
|
|
/*
|
|
** -- RELAT --
|
|
*/
|
|
case Types.Command.LT: self.stack.Lt(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.GT: self.stack.Gt(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.GE: self.stack.Ge(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.LE: self.stack.Le(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.EQ: self.stack.Eq(); self.processor.NextInstruction(1); break;
|
|
|
|
/*
|
|
** -- BOOL --
|
|
*/
|
|
case Types.Command.AND: self.stack.And(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.OR: self.stack.Or(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.NOT: self.stack.Not(); self.processor.NextInstruction(1); break;
|
|
case Types.Command.INV: self.stack.Inv(); self.processor.NextInstruction(1); break;
|
|
|
|
case Types.Command.END:
|
|
// END of code frame or end of transition table row reached?
|
|
if (self.coding.CheckCode(self.processor.CS[self.processor.IP+1],Types.Command.END)) {
|
|
self.admin=true;
|
|
self.break=true;
|
|
self.processor.PRO.pro_flag=Types.Process_state.PROC_STOP;
|
|
} else {
|
|
/*
|
|
** end of transition row found
|
|
** currently no transition condition can be satisfied,
|
|
** suspend the process, which is resumed on signal events
|
|
** !!! UFF: we must go back to start of transition row !!!
|
|
*/
|
|
// TBD
|
|
}
|
|
break;
|
|
|
|
default:
|
|
throw Error('[VM: invalid code '+self.processor.code+']: '+self.processor.Info(self.processor.PRO.pro_id));
|
|
};
|
|
if (!self.break && (ip_mon == self.processor.IP))
|
|
{
|
|
// mon_event(PRO,"EXCEPTION IP="+ToString(IP)+" CF="+ToString(CF));
|
|
self.break = true;
|
|
self.admin = true;
|
|
self.exception = true;
|
|
self.processor.PRO.pro_flag = Types.Process_state.PROC_EXCEPTION;
|
|
}
|
|
|
|
};
|
|
|
|
VM.prototype.signal = function (self) {
|
|
console.log('[VM '+self.id+'] Signal.');
|
|
};
|
|
|
|
VM.prototype.schedule = function (self) {
|
|
console.log('[VM '+self.id+'] Sched. [break='+self.break+' admin='+self.admin+' exception='+self.exception+']');
|
|
if (!self.notify) self.processor.Leave(self.token);
|
|
if (self.admin)
|
|
self.manager.tq.Outq(self.token);
|
|
else
|
|
self.tq.Outq(self.token);
|
|
|
|
};
|
|
|
|
VM.prototype.sleep = function (self) {
|
|
console.log('[VM '+self.id+'] Sleep.');
|
|
};
|
|
|
|
VM.prototype.transitions = function () {
|
|
var trans;
|
|
trans =
|
|
[
|
|
[undefined,this.init,function (self) {return true}],
|
|
[this.init,this.await,function (self) {return true}],
|
|
[this.await,this.setup,function (self) {return !self.context.blocked && self.token.tk_colour==Types.Token_colour.TK_PRO}],
|
|
[this.await,this.signal,function (self) {return !self.context.blocked && self.token.tk_colour==Types.Token_colour.TK_SIGH}],
|
|
[this.await,this.await,function (self) {return true}],
|
|
[this.setup,this.execute,function (self) {return true}],
|
|
[this.signal,this.setup,function (self) {return self.found}],
|
|
[this.signal,this.await,function (self) {return !self.found}],
|
|
[this.execute,this.schedule,function (self) {return self.break}],
|
|
[this.execute,this.execute,function (self) {return true}],
|
|
[this.schedule,this.await,function (self) {return true}]
|
|
];
|
|
return trans;
|
|
};
|
|
|
|
module.exports = {
|
|
VM: VM
|
|
};
|