lvm.js


var OP_MOVE = 0;
var OP_LOADK = 1;
var OP_LOADNIL = 3;
var OP_GETGLOBAL = 5;
var OP_SETGLOBAL = 7;
var OP_CALL = 28;
var OP_RETURN = 30;

var debugMode = false;

function LValue(type, value)
{
	this.type = type||"nil";
	this.value = value||null;
}

LValue.prototype = {
	call: function (args)
	{
		if(this.type == "function")
			return this.value;
		else
			throw "Attempt to call a " + this.type + " value";
	},
	index: function (key)
	{
		if(this.type == "table")
		{
			var val = this.value[key.value];
			if(typeof(val) == "undefined")
				return new LValue("nil", null);
			return val;
		}
		else
			throw "Attempt to index a " + this.type + " value";
	},
	setIndex: function (key, value)
	{
		if(this.type == "table")
		{
			this.value[key.value] = value;
		}
		else
			throw "Attempt to index a " + this.type + " value";
	}
};

function LValueFromString(string)
{
	return new LValue("string", string);
}

function LValueFromFunction(func)
{
	return new LValue("function", func);
}

var default_environment = new LValue("table", {});

var print;
if(typeof(document) == "object")
	print = function (a) { document.write(a+"<br/>") }; // Browser
else
	print = require("sys").puts; // Nodejs

default_environment.setIndex(LValueFromString("print"), LValueFromFunction(print));

function LFunction()
{
	this.constants = [];
	this.instructions = [];
	this.environment = default_environment;
	return this;
}

LFunction.prototype = {
	addInstruction: function (instruction)
	{
		this.instructions.push(instruction);
	},
	addConstant: function (constant)
	{
		this.constants.push(constant);
	}
};

function LVM()
{
	this.callstack = [];
	this.stack = [];
	return this;
}

LVM.prototype = {
	run: function (lfFunction)
	{
		this.frame = {f:lfFunction,pc:0,reg:[]};
		this.callstack.push(this.frame);
		var instruction;
		while(this.callstack.length>0)
		{
			instruction = this.frame.f.instructions[this.frame.pc++];
			switch(instruction[0])
			{
			case OP_MOVE:
				this.frame.reg[instruction[1]] = this.frame.reg[instruction[2]];
				break;
			case OP_LOADNIL:
				for(var i = instruction[1];i<=instruction[2];i++)
					this.frame.reg[i] = new LValue("nil", null);
				break;
			case OP_GETGLOBAL:
				var name = this.frame.f.constants[instruction[2]];
				this.frame.reg[instruction[1]] = this.frame.f.environment.index(name);
				break;
			case OP_SETGLOBAL:
				var name = this.frame.f.constants[instruction[2]];
				this.frame.f.environment.setIndex(name, this.frame.reg[instruction[1]]);
				break;
			case OP_LOADK:
				var value = this.frame.f.constants[instruction[2]];
				this.frame.reg[instruction[1]] = value;
				break;
			case OP_CALL:
				var f = this.frame.reg[instruction[1]].call(); // return JS or LValue
				var args = this.frame.reg.splice(instruction[1]+1, instruction[1]+(instruction[2]-1));
				if(typeof(f) == "function")
				{
					// JS native function
					var ret = f.apply(null, args.map(function (a) { return a.value; }));
				}
				else
				{
					// Lua function
				}
				break;
			case OP_RETURN:
				this.callstack.pop();
				break;
			default:
			}
		}
	}
};

var testvm = new LVM();
var mycode = new LFunction();

mycode.addConstant(LValueFromString("hello"));
mycode.addConstant(LValueFromString("print"));

mycode.addInstruction([OP_LOADK, 0, 0]);
mycode.addInstruction([OP_LOADNIL, 1, 1]);
mycode.addInstruction([OP_MOVE, 1, 0]);
mycode.addInstruction([OP_GETGLOBAL, 2, 1]);
mycode.addInstruction([OP_MOVE, 3, 1]);
mycode.addInstruction([OP_CALL, 2, 2, 1]);
mycode.addInstruction([OP_RETURN, 0, 1]);


try{
	testvm.run(mycode);
}
catch(e)
{
	print("Error: " + e);
}