/* VM

Execute the compiled bytecode. Inspired heavily by JonesFORTH, to a lesser degree by Postscript and HotRuby.

See:

http://replay.waybackmachine.org/20090209211708/http://www.annexia.org/forth

Notes to self:

The Array class is one of the few core classes that is not final, which

means that you can create your own subclass of Array. Hmmm.... probably a bad idea.

*/

package org.sixsided.scripting.SJS {

//import org.sixsided.scripting.SJS.Inspector;

import flash.utils.getDefinitionByName;

import flash.utils.getQualifiedClassName;

import flash.geom.*;

import flash.display.*;

import flash.events.Event;

import flash.events.EventDispatcher;

public class VM extends EventDispatcher {

public static var _VM_ID:int = 0;

public static var registry:Object = { Math:Math, Date:Date, 'null':null }; // TweenLite, etc goes here

public static function register(key:String, value:*) : void {

VM.registry[key] = value;

}

public static const MAX_RECURSION_DEPTH : int = 64;

/***********************************************************

*

* OPCODE IDs

*

***********************************************************/

public static const NOP:String = 'NOP';

public static const DUP:String = 'DUP';

public static const DROP:String = 'DROP';

/*public static const DROPALL:String = 'DROPALL';*/

public static const SWAP:String = 'SWAP';

public static const INDEX:String = 'INDEX';

public static const LIT:String = 'LIT';

public static const VAL:String = 'VAL';

public static const ADD:String = 'ADD';

public static const SUB:String = 'SUB';

public static const MUL:String = 'MUL';

public static const DIV:String = 'DIV';

public static const MOD:String = 'MOD';

public static const NEG:String = 'NEG';

public static const EQL:String = 'EQL';

public static const GT:String = 'GT';

public static const LT:String = 'LT';

public static const GTE:String = 'GTE';

public static const LTE:String = 'LTE';

public static const AND:String = 'AND';

public static const OR:String = 'OR';

public static const NOT:String = 'NOT';

public static const CLOSURE:String = 'CLOSURE';

public static const MARK:String = 'MARK';

public static const CLEARTOMARK:String = 'CLEARTOMARK';

public static const ARRAY:String = 'ARRAY';

public static const HASH:String = 'HASH';

public static const JUMP:String = 'JUMP';

public static const JUMPFALSE:String = 'JUMPFALSE';

public static const CALL:String = 'CALL';

public static const RETURN:String = 'RETURN';

/* public static const TRACE:String = 'TRACE';*/

public static const PUT:String = 'PUT';

public static const PUTINDEX:String = 'PUTINDEX';

public static const GETINDEX:String = 'GETINDEX';

public static const GET:String = 'GET';

public static const LOCAL:String = 'LOCAL';

public static const NATIVE_NEW:String = 'NATIVE_NEW';

public static const AWAIT:String = 'AWAIT';

public static const PUSH_RESUME_PROMISE:String = 'PUSH_RESUME_PROMISE';

//public static const HALT:String = 'HALT';

/***********************************************************

*

* EVENTS

*

***********************************************************/

public static const EXECUTION_COMPLETE:String = 'VM.EXECUTION_COMPLETE';

/***********************************************************

*

* VM STATE

*

***********************************************************/

public var _vm_id:String = ""+_VM_ID++;;

public var running:Boolean;

public var tracing:Boolean = false;

public var call_stack:Array = []; // function call stack

public var os:Array = []; // operand stack

public var marks:Array = []; // stack indices for array / hash construction

public var system_dicts:Array = []; // context; e.g. add a movie clip and script "x += 10"

public var vm_globals:Object = {}; // global scope, like you're used to in browser JavaScript:

/************************************************************

**

** PRIVATE API

**

************************************************************/

private function log(...args) : void {

if(tracing) {

_vmTrace('| ' + args.join(' '));

}

}

private function _vmTrace(...args) : void {

trace('[VM#'+_vm_id+']', args.join(' '));

}

private function _vmUserTrace(...args) : void {

_vmTrace(ANSI.cyan(args.join(' ')));

}

private function get _osAsString() : String {

return os.map(function(e:*, ...args) : String {

if (e is Function) { return '*fn*'; } return e;

}).join(' ');

}

private function next_word() : * {

return current_call.next_word();

}

private function get current_call():StackFrame {

return call_stack[0];

}

/***********************************************************

*

* PUBLIC API

*

***********************************************************/

public function VM() {

setGlobal('_trace', _vmUserTrace);

setGlobal('verbose_vm', _vmSetVerbosity);

setGlobal('halt', halt);

setGlobal('pushscope', pushDict);

setGlobal('popscope', popDict);

}

// for hotloading -- define a "clone me" function externally

// but make it a noop in the clone so you don't get

// infinite recursion

/* public function clone() : VM {

var ret:VM = new VM;

ret.load(call_stack[0].code);

return ret;

}

*/

public function _vmSetVerbosity(on:Boolean) : void {

tracing = on;

}

public function setGlobal(k:String, v:*) : void {

vm_globals[k] = v;

}

public function setGlobals(o:Object) : void {

for(var k:String in o) vm_globals[k] = o[k];

}

public function pushDict(dict:Object) : void {

system_dicts.unshift(dict);

trace('pushDict: now have', system_dicts.length);

}

public function popDict() : void {

system_dicts.shift();

trace('popDict: now have', system_dicts.length);

}

// can say vm.load(one_liner).run() with no trouble

// prebind the ops for speed?

public function load(tokens:Array) : VM {

call_stack = [ new StackFrame(tokens, {}) ];

return this;

}

public function loadString(code:String) : VM {

load(code.split(' '));

return this;

};

public function halt() : void {

running = false;

}

// == run ==

// some notes:@C

// Opcodes can only legally be of type String, although we interleave other types of data with them.

// we loop until reaching the end of the last stack frame, or until halted (running = false).

// we wrap (op) in extra parentheses to quiet Flash's "function where object expected" warning.

// we stash the callframe at the top of the inner loop in case next_word exhausts the StackFrame, causing it to be popped at the end of the loop

// have to do checks in loop in case we:

// - popped a frame last time through

// - exhausted callframe during run loop -- probably if/else jumping to end

//trace('VM.run; call_stack depth:', cs.length, 'pc @', cs[0].pc, '/', cs[0].code.length, '(', cs[0].code.join(' '), ')');

//trace('... bailing at end of cycle, call_stack depth:', cs.length, 'pc @', cs[0].pc, '/', cs[0].code.length, '(', cs[0].code.join(' '), ')');

// log(' VM Finished run. os: ', '[' + os.join(', ') + ']', ' dicts: ', Inspector.inspect(system_dicts), 'traces:', Inspector.inspect(dbg_traces), "\n");

//log(w, ANSI.wrap(ANSI.BLUE, ' ( ' + _osAsString + ' ) '));

public function run() : void {

var cs:Array = call_stack;

var op:Function;

running = true;

while(cs.length) {

while(cs.length && !current_call.exhausted && running) {

op = this[current_call.next_word()];

if(!(op)) {

if(current_call.exhausted) continue;

else throw new Error('VM got unknown operator ``' + current_call.prev_word() + "''");

}

op();

if(!running) return; // bail from AWAIT instruction

}

cpop(); // automatically return at end of function even if no return statement

}

running = false;

dispatchEvent(new Event(EXECUTION_COMPLETE));

}

public function onComplete(fn:Function) : void {

addEventListener(EXECUTION_COMPLETE, function _doOnComplete(...args) : void {

removeEventListener(EXECUTION_COMPLETE, _doOnComplete);

fn();

});

}

/**************************************************

**

** INTERNALS

**

***************************************************/

// call_stack manipulation. We prefer unshift/shift to push/pop because it's convenient that top-of-stack is always stack[0]

private function cpush(code:Array,vars:Object) : void {

call_stack.unshift(new StackFrame(code, vars, call_stack[0]));

}

private function cpop() : void {

call_stack.shift();

}

private function fcall(fn:VmFunc, args:Array) : void {

if(call_stack.length > VM.MAX_RECURSION_DEPTH) {

throw new Error('org.sixsided.scripting.SJS.VM: too much recursion in' + fn.name);

}

call_stack.unshift(new StackFrame(fn.body,

conformArgumentListToVmFuncArgumentHash(args, fn),

fn.parentScope));

}

// stack manipulation

private function opush(op:*):void { os.unshift(op); log(op, '->', '(', _osAsString, ')'); };

private function opop():* { log(os[0], '<-', '(', _osAsString, ')'); return os.shift(); };

private function numpop():Number { return parseFloat(opop()); };

private function bin_ops():Array { return [opop(), opop() ].reverse(); };

private function pushmark():void { marks.unshift(os.length); };

private function yanktomark():Array{ return os.splice(0, os.length - Number(marks.shift())).reverse(); }; // fixme: hack, ditch shift-stacks for push-stacks

// var manipulation

/* find_var/set_var

* VM has four tiers of variables.

* 1) the chain of StackFrame vars as defined by lexical scope

* 2) the VM's globals, vm_globals

* 3) the system dicts, in the order they were added -- READ ONLY; set_var does not even look at these

* 4) the VM's static registry, VM.registry

*

* *** The only writable vars are the current callframe's and the vm globals

* *** ... that is, locals and globals for a given VM. Just like Javascript.

* ....... Could add a 'register' function for adding things to the registry.

*/

// so running in the root scope, the 'var' keyword indicates a temporary variable tha won't persist after

// the call_stack is exhausted, i.e. the code runs through to its end and the vm exits.

// simply setting a variable with x = n, however, will create a persistent global x.

private function frameWithVar(key:String) : StackFrame {

var sf:StackFrame = call_stack[0];

var safety:int = MAX_RECURSION_DEPTH;

while(sf && safety--) {

if(sf.vars.hasOwnProperty(key)) {

return sf;

}

sf = sf.parent;

}

return null;

}

public function set_var(key:String, value:*) : void {

var sf:StackFrame = frameWithVar(key);

if(sf) {

sf.vars[key] = value;

return;

}

vm_globals[key] = value;

};

public function findVar(key:String) : * {

var v:* = _find_var(key);

return (undefined === v) ? null : v; // duhh why?

}

private function _keys(o : Object ) : Array {

var ret = [];

for(var k:String in o) {

ret.push(k);

}

return ret;

}

private function _find_var(key:String) : * {

// locals?

var sf:StackFrame = frameWithVar(key);

if(sf) {

return sf.vars[key];

}

// globals?

if(vm_globals.hasOwnProperty(key)) {

return vm_globals[key];

}

// dicts? (in LIFO order)

for (var i:int = 0; i < system_dicts.length; i++) {

//trace('look for', key, 'in #' + i + '/' + system_dicts.length +':', _keys(system_dicts[i]).join(' '));

var g:Object = system_dicts[i];

if(g.hasOwnProperty(key)) {

return g[key];

}

}

// registry?

if(VM.registry.hasOwnProperty(key)) {

return VM.registry[key];

}

// not defined anywhere!

return undefined;

};

/***********************************************************

*

* OPCODES

*

***********************************************************/

public function callScriptFunction(fnName:String, args:Array=null) : void {

_vmTrace('callScriptFunction', fnName);

var fn:* = findVar(fnName);

if(fn is Function) {

fn.apply(null, args);

} else if(fn is VmFunc) {

fcall(fn, args);

run();

} else {

throw "Tried to callScriptFunction on object " + fn;

}

}

// wrap VM functions in AS3 closures so we can pass them to AS3

// as event listeners, etc, that will fire up the vm

private function wrapVmFunc(fn:VmFunc):Function{

var vm:VM = this;

return function(...args):void {

vm.fcall(fn, args);

vm.run(); // if called from within SJS code, recurses into VM::run(); if called from an AS callback, starts up the interpreter

}

}

// fixme: replace for/in with for(i...

private function conformArgumentListToVmFuncArgumentHash(func_args:Array, fn:VmFunc):Object {

var ret:Object = {};

for (var i:String in fn.args) {

var k:String = fn.args[i];

ret[k] = func_args.shift();

}

return ret;

}

private function NOP():void { }

//stack manipulation

private function DUP() :void{ var p:* = opop(); opush(p); opush(p); }

private function DROP() :void{ opop(); }

private function CLEARTOMARK() :void{ yanktomark(); }

private function SWAP() :void{ var a:* = opop(); var b : * = opop(); opush(a); opush(b); }

private function INDEX() :void{ var index :*= opop(); opush(os[index]); }

//values

private function LIT():void{ var v:* = next_word(); opush(v); }

private function VAL():void{ opush(findVar(next_word())); }

//arithmetic

private function ADD():void{ var o:Array = bin_ops(); opush(o[0] + o[1]); }

private function SUB():void{ var o:Array = bin_ops(); opush(o[0] - o[1]);}

private function MUL():void{ var o:Array = bin_ops(); opush(o[0] * o[1]); }

private function DIV():void{ var o:Array = bin_ops(); opush(o[0] / o[1]); }

private function MOD():void{ var modulus:Number = numpop(); opush(numpop() % modulus); }

private function NEG():void{ opush(-opop()); }

//relational

private function EQL():void{ opush(opop() == opop()); }

private function GT() :void{ var o:Array = bin_ops(); opush(o[0] > o[1]); }

private function LT() :void{ var o:Array = bin_ops(); opush(o[0] < o[1]); }

private function GTE():void{ var o:Array = bin_ops(); opush(o[0] >= o[1]); }

private function LTE():void{ var o:Array = bin_ops(); opush(o[0] <= o[1]); }

//short-circuit logic operators -- for a() && b(), don't evaluate b() if a is falsy

// for a() || b(), don't evaluate b if a is truthy

private function _short_circuit_if(value:Boolean):void {

var right:*= opop();

var left:*= opop();

if(!!left == value) {

opush(left);

} else {

cpush(right, {});

// Creates a callframe/scope.

// "a && v = 3" will set v in global scope if not defined in the enclosing scope.

}

}

private function AND():void{ _short_circuit_if(false); }

private function OR():void { _short_circuit_if(true); }

private function NOT():void{ opush(!opop()); }

//structures

private function MARK():void { pushmark(); }

private function ARRAY():void { opush(yanktomark()); }

private function HASH():void {

var i:int, dict:Object = {}, a:Array = yanktomark();

for(i=0; i < a.length; i+=2) {

dict[a[i]] = a[i+1];

}

opush(dict);

}

//flow control

private function JUMP():void{

current_call.pc += next_word();

}

private function JUMPFALSE():void{

var prevpc:int = current_call.pc;

var offset:int = next_word();

if(!opop()) {

current_call.pc += offset;

}

}

//functions

private function CLOSURE():void{

var closure:Function;

log(Inspector.inspect(os));

var body:Array= opop();

var args:Array= opop();

var name:String = opop();

// used to wrap vm functions in AS3 functions here

var vmf:VmFunc = new VmFunc(name, args, body, call_stack[0]);

set_var(name, vmf);

opush(vmf);

}

// TODO -- supply a "this" context for scripted functions?

// FIXME -- How to distinguish between functions returning nothing and functions

// returning undefined? For now, we don't. (function.length is the js way)

// we allow both wrapped and unwrapped functions because they're both useful:

// wrapped functions for passing to AS3 as e.g. event listeners which retain

// a reference to this VM in their closures;

// unwrapped functions so we can run code from another VM in our own context

private function CALL():void { // (closure args_array -- return_value

var func_args:* = opop();

var fn:* = opop();

var rslt:*;

//trace('VM.CALL', (fn is Function) ? 'native' : fn, 'args:', func_args);

if(fn is Function) {

rslt = fn.apply(NaN, func_args); // NaN is flash's default; presumably it means "don't rebind this"

if(rslt !== undefined) opush(rslt);

} else if(fn is VmFunc) {

fcall(fn, func_args);

} else {

trace('* * * * * VM.CALL tried to call nonfunction value "' + fn + '": ' + typeof(fn) + ' * * * * * *');

}

}

private function RETURN():void{

log('return');

cpop();

}

// getting and setting values

private function GET ():void {

var key:String = opop();

opush(findVar(key));

}

// v k PUT

private function PUT():void{ // (value key -- value )

var key:String = opop();

var value:* = opop();

log('PUT', value, key);

set_var(key, value);

// opush(value);

}

private function PUTLOCAL():void{ // (value key -- value )

// TODO: figure out scopes in parser/codegen

// or just generate PUTLOCAL anywhere you see "var x;" (gets null or undefined) or "var x = value":

var key:String = opop();

var value:* = opop();

log('PUTLOCAL', value, key);

call_stack[0].vars[key] = value;

// opush(value);

}

// value object key PUTINDEX

private function PUTINDEX():void{ // ( value object key -- value )

var key :* = opop();

var object:* = opop();

var value :* = opop();

object[key] = value;

// opush(value);

}

private function GETINDEX():void{ // aka "dot" (o k -- o[k])

var k:* = opop();

var o:* = opop();

// trace('GETINDEX', o, k);

opush(o[k]);

}

// LIT m LOCAL -- declares m as a var in current scope

private function LOCAL():void {

var key:String = opop();

current_call.vars[key] = undefined;

}

// NEW ( constructor [args] -- instance )

private function NATIVE_NEW():void {

var args:Array = opop();

var classname:String = opop();

var klass:Class = findVar(classname);

var instance:*;

log('++ new ', classname, '(' + args.join(', ') + ') //', klass + ': ' + getQualifiedClassName(klass));

switch(args.length) {

case 0: instance = new klass(); break;

case 1: instance = new klass(args[0]); break;

case 2: instance = new klass(args[0], args[1]); break;

case 3: instance = new klass(args[0], args[1], args[2]); break;

case 4: instance = new klass(args[0], args[1], args[2], args[3]); break;

case 5: instance = new klass(args[0], args[1], args[2], args[3], args[4]); break;

case 6: instance = new klass(args[0], args[1], args[2], args[3], args[4], args[5]); break;

case 7: instance = new klass(args[0], args[1], args[2], args[3], args[4], args[5], args[6]); break;

case 8: instance = new klass(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7]); break;

case 9: instance = new klass(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]); break;

default: throw "NATIVE_NEW was given too many arguments: " + args.length;

}

opush(instance);

}

private function _resumeFromPromise(...promiseFulfillArgs) : void {

log('_resumeFromPromise', promiseFulfillArgs);

// convert all cases to 1-arg.

// 0: null

// 1: pass through

// N: pass as an array

if(promiseFulfillArgs.length == 0) {

opush(null);

} else if(promiseFulfillArgs.length == 1) {

opush(promiseFulfillArgs[0]);

} else {

opush(promiseFulfillArgs);

}

run();

}

private function AWAIT():void {

var p:Promise = opop();

halt();

p.onFulfill(_resumeFromPromise);

}

} // VM

} // package