ljs: comparison lvm.js

comparison: lvm.js

lvm.js

changeset 128: 29c56996fa03
parent 127: 9a4c549c7828
child 129: 6784d462999f

equal deleted inserted replaced

-:9a4c549c7828
+:29c56996fa03
 }
 LValue.prototype = {
 	call: function (args)
 	{
-		var f = this.precall();
+		var ret = this.vm.call(this, args);
-		var ret = this.vm.call(f, args);
 		if(typeof(ret) == "undefined")
 			ret = [];
 		return ret;
 	},
 	precall: function ()
 			(ins>>14)&0x1FF // Field C
 		]);
 		if(debugMode)
 		{
 			var pi = this.instructions[this.instructions.length-1];
-			sys.puts("Pos: "+(this.pos-4)+" Ins: "+ins+" OP: "+INS_OPCODE(pi)+" A: "+INS_A(pi)+" B: "+INS_B(pi)+" C: "+INS_C(pi)+" Bx: "+INS_Bx(pi)+" sBx: "+(INS_Bx(pi)-0x1FFFE));
+			//sys.puts("Pos: "+(this.pos-4)+" Ins: "+ins+" OP: "+INS_OPCODE(pi)+" A: "+INS_A(pi)+" B: "+INS_B(pi)+" C: "+INS_C(pi)+" Bx: "+INS_Bx(pi)+" sBx: "+(INS_Bx(pi)-0x1FFFE));
 		}
 	}
 	this.constants = [];
 		default:
 			throw "Not able to convert type " +
 				typeof(value)+" from Javascript to Lua";
 		}
 	},
-	call: function (lfFunction, args)
+	call: function (func, args)
 	{
-		if(typeof(lfFunction) == "function")
+		var f = func.precall();
-		{
+		if(typeof(f) == "function")
-			return lfFunction.apply(this, args);
+		{
+			return f.apply(this, args);
 		}
 		else
 		{
-			var frame = {f:lfFunction,pc:0,entry:true};
+			var frame = {f:f,pc:0,entry:true};
 			if(args)
 				frame.reg = args.slice(0);
 			else
 				frame.reg = [];
 			this.callstack.push(frame);
-			for(var i=frame.reg.length;i<lfFunction.maxStackSize;i++)
+			for(var i=frame.reg.length;i<f.maxStackSize;i++)
 				frame.reg[i] = this.LValue(null);
 			return this.run(frame);
 		}
 	},
 	run: function(frame)
 					args[i] = new LValue(this, "nil", null);
 				// Patch frame for new function
 				frame.f = f; frame.pc = 0; frame.reg = args;
 				break;
 			case OP_CALL:
-				var f = frame.reg[INS_A(instruction)].precall(); // return JS or LValue
+				var f = frame.reg[INS_A(instruction)].precall(); // return JS or LFunction
 				var A = INS_A(instruction), B = INS_B(instruction), C = INS_C(instruction);
 				var undefined;
 				var args;
 				if(B != 1)
 					args = frame.reg.slice(A+1, B==0?undefined:(A+B));
 				if(B != 0)
 					frame.reg.length = A+B;
 				if(typeof(f) == "function")
 				{
 					// JS native function
-					var ret = this.call(f, args);
+					var ret = this.call(frame.reg[INS_A(instruction)], args);
 					// Insert ret to reg starting at R(A), with C-1 limit
 					var nresults = ret.length;
 					var nexpected;
 					if(C == 0)
 					{
 				}
 				break;
 			case OP_TFORLOOP:
 				var A = INS_A(instruction);
 				var C = INS_C(instruction);
-				var f = frame.reg[A].precall(); // Iterator function
+				var RA = frame.reg[A]; // Iterator function
-				var rets = this.call(f, [frame.reg[A+1], frame.reg[A+2]]);
+				var rets = this.call(RA, [frame.reg[A+1], frame.reg[A+2]]);
 				frame.reg.length = A+3;
 				for(var i = 0; i<C; i++)
 					frame.reg[A+3+i] = rets[i];
 				if(frame.reg[A+3].type != "nil")
 					frame.reg[A+2] = frame.reg[A+3];
 		else
 			t = env; // Import directly into env
 		for(var k in lib)
 			t.setIndex(this.LValue(k), this.LValue(lib[k]));
+	},
+	loadstring: function (chunk, env)
+	{
+		var c = new LBinaryChunk(this, chunk);
+		var f = new LFunction(this, c, env);
+		return new LValue(this, "function", f);
 	}
 };
 try{
 var testvm = new LVM();
 var fs=require("fs");
 var sys=require("sys");
-var c = new LBinaryChunk(testvm, fs.readFileSync("luac.out", "binary"));
 var _G = testvm.LValue([]);
 // Standard library
 	testvm.LValue(function (t, k) { sys.puts("Access of nil global: "+k); })
 );
 _G.setMetatable(mt);
-var f = new LFunction(testvm, c, _G);
+var f = testvm.loadstring(fs.readFileSync("luac.out", "binary"), _G);
 	var ret = testvm.call(f);
 	if(ret)
 		sys.puts("Returned: "+sys.inspect(ret));
 }