root/as2/E3Engine/VirtualMachine.as

class VirtualMachine
{
        private var byteCode:Array;
        private var byteCodeLength:Number;
        
        private var programCounter:Number;
        
        private var global:Object;
        private var localObject:Object;
        private var thisObject:Object;
        
        private var returnValue:Object;
        
        private var stack:Array;
        
        public function VirtualMachine ()
        {
                initialize();
        }
        
        public function initialize () : Void
        {
                programCounter = 1;
                byteCode = new Array();
                
                stack = new Array();
                
                global = new Object();
                global.__scope = null;
                localObject = global;
                thisObject = global;
        }
        
        public function getGlobalObject () : Object
        {
                return global;
        }
        public function setByteCode (byteCode:Array) : Void
        {
                this.byteCode = byteCode;
                byteCodeLength = byteCode.length;
        }
        
        public function execute () : Boolean
        {
                var _byteCode:Array = byteCode;
                var _programCounter:Number = programCounter;
                
                var _byteCodeLength:Number = byteCodeLength;
                
                var next:Number;
                
                for (; _programCounter < _byteCodeLength; ) {
                        // trace("proccess : "+("00"+_programCounter).substr(-2,2)+" : "+_byteCode[_programCounter]);
                        if ((next = this[_byteCode[_programCounter]](_byteCode, _programCounter)) == null) {
                                
                                programCounter = _programCounter + 1;
                                // このタイミングでいらない値は破棄しておこう．．．
                                delete _byteCode[0];
                                
                                return true;
                        }
                        _programCounter = next;
                }
                
                programCounter = _programCounter;
                
                // このタイミングでいらない値は破棄しておこう．．．
                delete _byteCode[0];
                
                return false;
        }
        
        private function executeFunction (thisObject:Object, args:Array, entryPoint:Number, scope:Object) : Object
        {
                var _thisObject:Object = this.thisObject;
                var _localObject:Object = localObject;
                var _programCounter:Number = programCounter;
                
                this.thisObject = thisObject;
                localObject = {arguments: args, __scope:scope};
                programCounter = entryPoint;
                
                while (execute()) {}
                
                programCounter = _programCounter;
                localObject = _localObject;
                this.thisObject = _thisObject;
                
                return returnValue;
        }
        
        private function __resolve (name:String) : Number
        {
                throw new Error('VirtualMachine [UnknwonOperation] : '+name+' at pc'+arguments[1]);
                return 0;
        }
        //
        //nop
        //(no operation)
        //何もしない
        private function NOP (code:Array, pc:Number) : Number
        {
                return pc+1;
        }
        //
        //spd
        //(suspend)
        //処理を中断する
        private function SPD (code:Array, pc:Number) : Number
        {
                return null;
        }
        //
        //lit v %
        //(literal)
        //リテラルvを%に代入
        private function LIT (code:Array, pc:Number) : Number
        {
                code[code[pc+2]] = code[pc+1];
                
                return pc+3;
        }
        //
        //call id n %
        //(call function)
        //関数idをn個の引数で呼び出して結果を%に代入
        private function CALL (code:Array, pc:Number) : Number
        {
                var id:String = code[pc+1];
                
                var func:Object = null;
                
                for (var o:Object = localObject; o != null; o = o.__scope) {
                        if (o.hasOwnProperty(id)) {
                                func = o[id];
                                break;
                        }
                }
                
                var numOfArguments:Number = code[pc+2] + 1;
                var _stack:Array = stack;
                var args:Array = [];
                while (--numOfArguments) {
                        args.push(_stack.pop());
                }
                args.reverse();
                
                if (func.__entryPoint !== undefined) {
                        _stack.push(pc+4);
                        _stack.push(thisObject);
                        _stack.push(localObject);
                        _stack.push(code[pc+3]);
                        
                        thisObject = global;
                        localObject = {arguments: args, __scope: func.__scope};
                        
                        return func.__entryPoint;
                }
                
                code[code[pc+3]] = func.apply(global, args);
                return pc+4;
        }
        //
        //calll id n %
        //(call local function)
        //関数idをn個の引数で呼び出して結果を%に代入
        private function CALLL (code:Array, pc:Number) : Number
        {
                var func:Object = localObject[code[pc+1]];
                
                var numOfArguments:Number = code[pc+2] + 1;
                var _stack:Array = stack;
                var args:Array = [];
                while (--numOfArguments) {
                        args.push(_stack.pop());
                }
                args.reverse();
                
                if (func.__entryPoint !== undefined) {
                        _stack.push(pc+4);
                        _stack.push(thisObject);
                        _stack.push(localObject);
                        _stack.push(code[pc+3]);
                        
                        thisObject = global;
                        localObject = {arguments: args, __scope: func.__scope};
                        
                        return func.__entryPoint;
                }
                
                code[code[pc+3]] = func.apply(global, args);
                return pc+4;
        }
        //
        //callm o id n %
        //(call member function)
        //関数v.idをn個の引数で呼び出して結果を%に代入
        private function CALLM (code:Array, pc:Number) : Number
        {
                var o:Object = code[pc+1];
                
                var func:Object = o[code[pc+2]];
                
                var numOfArguments:Number = code[pc+3] + 1;
                var _stack:Array = stack;
                var args:Array = [];
                while (--numOfArguments) {
                        args.push(_stack.pop());
                }
                args.reverse();
                
                if (func.__entryPoint !== undefined) {
                        _stack.push(pc+5);
                        _stack.push(thisObject);
                        _stack.push(localObject);
                        _stack.push(code[pc+4]);
                        
                        thisObject = o;
                        localObject = {arguments: args, __scope: func.__scope};
                        
                        return func.__entryPoint;
                }
                
                code[code[pc+4]] = func.apply(o, args);
                return pc+5;
        }
        //
        //callf o n %
        //(call functor)
        //関数オブジェクトoをn個の引数で呼び出して結果を%に代入
        private function CALLF (code:Array, pc:Number) : Number
        {
                var func:Object = code[pc+1];
                
                var numOfArguments:Number = code[pc+2] + 1;
                var _stack:Array = stack;
                var args:Array = [];
                while (--numOfArguments) {
                        args.push(_stack.pop());
                }
                args.reverse();
                
                if (func.__entryPoint !== undefined) {
                        _stack.push(pc+4);
                        _stack.push(thisObject);
                        _stack.push(localObject);
                        _stack.push(code[pc+3]);
                        
                        thisObject = global;
                        localObject = {arguments: args, __scope: func.__scope};
                        
                        return func.__entryPoint;
                }
                
                code[code[pc+3]] = func.apply(global, args);
                return pc+4;
        }
        //
        //ret v
        //(return function)
        //戻り値vで関数の呼び出し元に戻る
        private function RET (code:Array, pc:Number) : Number
        {
                returnValue = code[pc+1];
                
                return byteCodeLength;
        }
        //
        //cret v
        //(return coroutine)
        //戻り値vでコルーチンの呼び出し元に戻る
        private function CRET (code:Array, pc:Number) : Number
        {
                var _stack:Array = stack;
                
                code[_stack.pop()] = code[pc+1];
                
                localObject = _stack.pop();
                thisObject = _stack.pop();
                
                return Number(_stack.pop());
        }
        //
        //func :% %
        //(function declare)
        //:%までを本体とする関数オブジェクトを生成して%に代入
        private function FUNC (code:Array, pc:Number) : Number
        {
                var vm:VirtualMachine = this;
                var entryPoint:Number = pc + 3;
                var scope:Object = localObject;
                code[code[pc+2]] = function ()
                {
                        return vm.executeFunction(this, arguments, entryPoint, scope);
                };
                return code[pc+1];
        }
        //
        //cor :% %
        //(coroutine declare)
        //:%までを本体とするコルーチンを生成して%に代入
        private function COR (code:Array, pc:Number) : Number
        {
                code[code[pc+2]] = {__entryPoint:pc+3, __scope:localObject};
                return code[pc+1];
        }
        //
        //arg n id
        //(get argument)
        //n番目の引数を変数idに代入
        private function ARG (code:Array, pc:Number) : Number
        {
                localObject[code[pc+2]] = localObject.arguments[code[pc+1]];
                
                return pc+3;
        }
        //
        //jmp :%
        //(jump)
        //:%に飛ぶ
        private function JMP (code:Array, pc:Number) : Number
        {
                return code[pc+1];
        }
        //
        //if v :%
        //(jump if)
        //vが真で「なければ」:%に飛ぶ（真であれば次のコードが実行される）
        private function IF (code:Array, pc:Number) : Number
        {
                if (code[pc+1]) {
                        return pc+3;
                }
                return code[pc+2];
        }
        //
        //nif v :%
        //(jump if not)
        //vが偽で「なければ」:%に飛ぶ（偽であれば次のコードが実行される）
        private function NIF (code:Array, pc:Number) : Number
        {
                if (code[pc+1]) {
                        return code[pc+2];
                }
                return pc+3;
        }
        //
        //add v1 v2 %
        //(add)
        //v1+v2を%に代入
        private function ADD (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1] + code[pc+2];
                return pc+4;
        }
        //
        //sub v1 v2 %
        //(subtract)
        //v1-v2を%に代入
        private function SUB (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1] - code[pc+2];
                return pc+4;
        }
        //
        //mul v1 v2 %
        //(multiply)
        //v1*v2を%に代入
        private function MUL (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1] * code[pc+2];
                return pc+4;
        }
        //
        //div v1 v2 %
        //(divide)
        //v1/v2を%に代入
        private function DIV (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1] / code[pc+2];
                return pc+4;
        }
        //
        //mod v1 v2 %
        //(modulo)
        //v1%v2を%に代入
        private function MOD (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1] % code[pc+2];
                return pc+4;
        }
        //
        //and v1 v2 %
        //(bitwise and)
        //v1&v2を%に代入
        private function AND (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1] & code[pc+2];
                return pc+4;
        }
        //
        //or v1 v2 %
        //(bitwise or)
        //v1|v2を%に代入
        private function OR (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1] | code[pc+2];
                return pc+4;
        }
        //
        //xor v1 v2 %
        //(bitwise xor)
        //v1^v2を%に代入
        private function XOR (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1] ^ code[pc+2];
                return pc+4;
        }
        //
        //not v %
        //(bitwise not)
        //~vを%に代入
        private function NOT (code:Array, pc:Number) : Number
        {
                code[code[pc+2]] = ~code[pc+1];
                return pc+3;
        }
        //
        //lnot v %
        //(logical not)
        //!vを%に代入
        private function LNOT (code:Array, pc:Number) : Number
        {
                code[code[pc+2]] = !code[pc+1];
                return pc+3;
        }
        //
        //lsh v1 v2 %
        //(left shift)
        //v1<<v2を%に代入
        private function LSH (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1] << code[pc+2];
                return pc+4;
        }
        //
        //rsh v1 v2 %
        //(signed right shift)
        //v1>>v2を%に代入
        private function RSH (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1] >> code[pc+2];
                return pc+4;
        }
        //
        //ursh v1 v2 %
        //(unsigned right shift)
        //v1>>>v2を%に代入
        private function URSH (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1] >>> code[pc+2];
                return pc+4;
        }
        //
        //inc v %
        //(increment)
        //vを加算して%に代入
        private function INC (code:Array, pc:Number) : Number
        {
                code[code[pc+2]] = code[pc+1] + 1;
                return pc+3;
        }
        //
        //dec v %
        //(decrement)
        //vを減算して%に代入
        private function DEC (code:Array, pc:Number) : Number
        {
                code[code[pc+2]] = code[pc+1] - 1;
                return pc+3;
        }
        //
        //ceq v1 v2 %
        //(compare equal)
        //v1==v2の結果を%に代入
        private function CEQ (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1] == code[pc+2];
                return pc+4;
        }
        //
        //cseq v1 v2 %
        //(compare strict equal)
        //v1===v2の結果を%に代入
        private function CSEQ (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1] === code[pc+2];
                return pc+4;
        }
        //
        //cne v1 v2 %
        //(compare not equal)
        //v1!=v2の結果を%に代入
        private function CNE (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1] != code[pc+2];
                return pc+4;
        }
        //
        //csne v1 v2 %
        //(compare not strict equal)
        //v1!==v2の結果を%に代入
        private function CSNE (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1] !== code[pc+2];
                return pc+4;
        }
        //
        //clt v1 v2 %
        //(compare less than)
        //v1<v2の結果を%に代入
        private function CLT (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1] < code[pc+2];
                return pc+4;
        }
        //
        //cgt v1 v2 %
        //(compare greater than)
        //v1>v2の結果を%に代入
        private function CGT (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1] > code[pc+2];
                return pc+4;
        }
        //
        //cle v1 v2 %
        //(compare less than or equal)
        //v1<=v2の結果を%に代入
        private function CLE (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1] <= code[pc+2];
                return pc+4;
        }
        //
        //cge v1 v2 %
        //(compare greater than or equal)
        //v1>=v2の結果を%に代入
        private function CGE (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1] >= code[pc+2];
                return pc+4;
        }
        //
        //dup v %1 %2
        //(duplicate)
        //%1と%2にvを代入
        private function DUP (code:Array, pc:Number) : Number
        {
                var value:Object = code[pc+1];
                code[code[pc+2]] = value;
                code[code[pc+3]] = value;
                return pc+4;
        }
        //
        //this %
        //(this)
        //thisを%に代入
        private function THIS (code:Array, pc:Number) : Number
        {
                code[code[pc+1]] = thisObject;
                return pc+2;
        }
        //
        //array n %
        //(initialize array)
        //n個の要素を持つ配列を生成して%に代入
        private function ARRAY (code:Array, pc:Number) : Number
        {
                var elements:Number = code[pc+1];
                var instance:Array = new Array(elements);
                var _stack:Array = stack;
                for (var i:Number=0; i<elements; ++i) {
                        instance[i] = _stack.pop();
                }
                instance.reverse();
                code[code[pc+2]] = instance;
                return pc+3;
        }
        //
        //obj n %
        //(initialize object)
        //n個のキーと値のペアを持つオブジェクトを生成して%に代入
        private function OBJ (code:Array, pc:Number) : Number
        {
                var properties:Number = code[pc+1];
                var instance:Object = new Object();
                var _stack:Array = stack;
                for (var i:Number=0; i<properties; ++i) {
                        var value:Object = _stack.pop();
                        instance[_stack.pop()] = value;
                }
                code[code[pc+2]] = instance;
                return pc+3;
        }
        //
        //setl id v %
        //(set local variable)
        //現在の実行コンテキスト上の変数idにvを代入（変数idが存在しなければ生成; スコープチェーンは見ない）
        private function SETL (code:Array, pc:Number) : Number
        {
                localObject[code[pc+1]] = code[code[pc+3]] = code[pc+2];
                return pc+4;
        }
        //
        //getl id %
        //(get local variable)
        //現在の実行コンテキスト上の変数idを探して%に代入（スコープチェーンは見ない）
        private function GETL (code:Array, pc:Number) : Number
        {
                code[code[pc+2]] = localObject[code[pc+1]];
                return pc+3;
        }
        //
        //set id v %
        //(set variable)
        //現在の実行コンテキストを基点とするスコープチェーンから変数idを探してvを代入
        private function SET (code:Array, pc:Number) : Number
        {
                var id:String = code[pc+1];
                for (var o:Object = localObject; o != null; o = o.__scope) {
                        if (o.hasOwnProperty(id)) {
                                o[id] = code[code[pc+3]] = code[pc+2];
                                return pc+4;
                        }
                }
                global[id] = code[code[pc+3]] = code[pc+2];
                return pc+4;
        }
        //
        //get id %
        //(get variable)
        //現在の実行コンテキストを基点とするスコープチェーンから変数idを探して%に代入
        private function GET (code:Array, pc:Number) : Number
        {
                var id:String = code[pc+1];
                for (var o:Object = localObject; o != null; o = o.__scope) {
                        if (o.hasOwnProperty(id)) {
                                code[code[pc+2]] = o[id];
                                return pc+3;
                        }
                }
                code[code[pc+2]] = undefined;
                return pc+3;
        }
        //
        //setm o id v %
        //(set member)
        //o.idにvを代入
        private function SETM (code:Array, pc:Number) : Number
        {
                code[pc+1][code[pc+2]] = code[code[pc+4]] = code[pc+3];
                return pc+5;
        }
        //
        //getm o id %
        //(get member)
        //o.idを%に代入
        private function GETM (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1][code[pc+2]];
                return pc+4;
        }
        //
        //new v n %
        //(new instance)
        //クラスvをn個の引数で生成して%に代入
        private function NEW (code:Array, pc:Number) : Number
        {
                var constructor:Function = code[pc+1];
                _constructor.prototype = constructor.prototype;
                var instance:Object = new _constructor();
                var argLen:Number = code[pc+2]+1;
                var _stack:Array = stack;
                var args:Array = [];
                while (--argLen) {
                        args.push(_stack.pop());
                }
                code[code[pc+3]] = constructor.apply(instance, args) || instance;
                return pc+4;
        }
        private function _constructor () : Void
        {
        }
        //
        //del id %
        //(delete)
        //変数idを削除し、その成否を%に代入
        private function DEL (code:Array, pc:Number) : Number
        {
                var id:String = code[pc+1];
                for (var o:Object = localObject; o != null; o = o.__scope) {
                        if (o.hasOwnProperty(id)) {
                                code[code[pc+2]] = delete o[id];
                                return pc+3;
                        }
                }
                code[code[pc+2]] = false;
                return pc+3;
        }
        //
        //dell id %
        //(delete local)
        //変数idを削除し、その成否を%に代入
        private function DELL (code:Array, pc:Number) : Number
        {
                code[code[pc+2]] = delete localObject[code[pc+1]];
                return pc+3;
        }
        //
        //delm o id %
        //(delete member)
        //o.idを削除し、その成否を%に代入
        private function DELM (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = delete code[pc+1][code[pc+2]];
                return pc+4;
        }
        //
        //typeof v %
        //(typeof)
        //typeof vの結果を%に代入
        private function TYPEOF (code:Array, pc:Number) : Number
        {
                code[code[pc+2]] = typeof code[pc+1];
                return pc+3;
        }
        //
        //insof v1 v2 %
        //(instanceof)
        //v1 instanceof v2の結果を%に代入
        private function INSOF (code:Array, pc:Number) : Number
        {
                code[code[pc+3]] = code[pc+1] instanceof code[pc+2];
                return pc+4;
        }
        //
        //num v %
        //(to number)
        //Number(v)の結果を%に代入
        private function NUM (code:Array, pc:Number) : Number
        {
                code[code[pc+2]] = Number(code[pc+1]);
                return pc+3;
        }
        //
        //str v %
        //(to string)
        //String(v)の結果を%に代入
        private function STR (code:Array, pc:Number) : Number
        {
                code[code[pc+2]] = String(code[pc+1]);
                return pc+3;
        }
        //
        //with v
        //(start with)
        //スコープチェーンの先頭にvを追加
        private function WITH (code:Array, pc:Number) : Number
        {
                var o:Object = code[pc+1];
                
                o.__scope = localObject;
                localObject = o;
                
                return pc+2;
        }
        //
        //ewith
        //(end with)
        //スコープチェーンから先頭のオブジェクトを取り除く
        private function EWITH (code:Array, pc:Number) : Number
        {
                localObject = localObject.__scope;
                return pc+1;
        }
        //
        //push v
        //(push)
        //vをスタックに積む
        private function PUSH (code:Array, pc:Number) : Number
        {
                stack.push(code[pc+1]);
                return pc+2;
        }
        //
        //pop %
        //(pop)
        //スタックから値を取り出し%に代入
        private function POP (code:Array, pc:Number) : Number
        {
                code[code[pc+1]] = stack.pop();
                return pc+2;
        }
        
        /* FECMAScriptɂN[W̊TO
        
        eFunctiońA`ꂽꏊɂXR[v`F[A
        vpeBƂρB
        
        j
        globalɒ`ꂽ֐f́AglobalXR[v`F[ɎB
        f().__proto__ == global
        fɒ`ꂽ֐ǵAfActivationObjectXR[v`F[ɎB
        g().__proto__ == ActivationObject(f)
        ActivationObject(f).__proto__ = f().__proto__
        
        eFunctionJnƂAActivationObjecti[Jϐ
        i[̈̂悤Ȃ́jÃXR[v`F[͊֐̂
        ƒXR[v`F[ɐݒ肳B
        
        ɂA
        
        ///////////////////////////////////////
        var a:Number = 1;
        
        function f (g:Function) : Void
        {
                var b:Number = 1;
                a = g(b);
        }
        
        f(function(n:Number) : Number
        {
                return a + n;
        });
        ///////////////////////////////////////
        
        ƂR[h́A֐fA֐igjɃO[o̕ϐa
        ANZXł̂łB
        
        ֐fϐQƂƂA
        ActivationObject(f) (-> ActivationObject(f).__proto__ -> f().__proto__) -> global
        ƂŎQƂA֐ϐaQƂƂl̎菇ōsB
        
        ֐ϐQƂƂA
        ActivationObject() (-> ActivationObject().__proto__ -> ().__proto__) -> global
        ƂŎQƂ邽߁A֐f̕ϐbɂ̓ANZXłȂB
        
        ϐbActivationObject(f)ɍ쐬B
        
        */
}