public override RunTimeValueBase getMethod(rtObjectBase rtObj)
{
//if (cache.IsAlive)
//{
// if (ReferenceEquals(((rtFunction)cache.Target).this_pointer, rtObj))
// {
// if (((rtFunction)cache.Target).this_pointer == rtObj)
// {
// return (rtFunction)cache.Target;
// }
// }
//}
var instance_class = rtObj.value._class;
if (instance_class.isInterface && instance_class.isLink_System)
{//***可能是链接到系统的接口****
#if DEBUG
if (instance_class != _class)
{
if (!instance_class.implements.ContainsKey(_class))
{
throw new ASRuntime.EngineException();
}
}
#endif
var vmember = (InterfaceMethodGetter)_class.classMembers[indexofMember].bindField;
//rtData.rtFunction method = new rtData.rtFunction(vmember.functionId, true);
//method.bind(rtObj.objScope);
//method.setThis(rtObj);
//cache.Target = method;
//return method;
_cachemethod.SetValue(vmember.functionId, true);
_cachemethod.bind(rtObj.objScope);
_cachemethod.setThis(rtObj);
return(_cachemethod);
}
else
{
var vmember = (ClassMethodGetter)instance_class.classMembers[instance_class.implements[_class][indexofMember]].bindField;
//rtData.rtFunction method = new rtData.rtFunction(vmember.functionId, true);
//method.bind(rtObj.objScope);
//method.setThis(rtObj);
//cache.Target = method;
//return method;
_cachemethod.SetValue(vmember.functionId, true);
_cachemethod.bind(rtObj.objScope);
_cachemethod.setThis(rtObj);
return(_cachemethod);
}
}
private void _primitive_toObj(ASBinCode.RunTimeValueBase v1,
ASBinCode.RunTimeValueBase v_temp,
StackFrame frame,ASBinCode.OpStep step,
ASBinCode.RunTimeScope scope)
{
var c = stackCallers.Pop();
if (v1.rtType < RunTimeDataType.unknown)
{
c.SetFunctionThis(null);
}
else
{
rtObjectBase rtObj = (rtObjectBase)v1;
c.SetFunctionThis(rtObj);
}
if (!c.createParaScope())
{
return;
}
SLOT[] argements = (SLOT[])c.tag;
if (argements[1].getValue().rtType != rtNull.nullptr.rtType)
{
rtArray argArray = (rtArray)argements[1].getValue();
for (int i = 0; i < argArray.innerArray.Count; i++)
{
bool success;
c.pushParameter(argArray.innerArray[i],i,out success);
}
}
c.call();
}
public override void clear()
{
setindex = null;
bindObj = null;
set_this_item = null;
get_this_item = null;
}
public static void bindFunctionWhenCreate(rtFunction function, StackFrame frame, RunTimeScope scope, int defclassid)
{
if (function.bindScope == null
||
function.bindScope.blockId == frame.scope.blockId
)
{
function.bind(frame.scope);
}
if (!function.ismethod)
{
if (function.this_pointer == null)
{
var s = frame.scope;
if (s.this_pointer != null && s.this_pointer is rtObjectBase)
{
rtObjectBase obj = (rtObjectBase)s.this_pointer;
if (obj.value is Global_Object)
{
function.setThis(obj);
}
else
{
var cls = frame.player.swc.classes[defclassid]; //obj.value._class;
if (cls.staticClass == null)
{
cls = cls.instanceClass;
}
if (cls.mainClass != null)
{
cls = cls.mainClass;
}
if (frame.player.outpackage_runtimescope.ContainsKey(cls.classid))
{
var ot = frame.player.outpackage_runtimescope[cls.classid];
function.setThis(ot.this_pointer);
}
else
{
//***此处只有在$Object启动时发生***
function.setThis(obj);
}
}
}
else
{
if (frame.player.infoOutput != null)
{
frame.player.infoOutput.Warring("当前函数没有this指针。也许不是从文档类启动，而是从包外代码启动的");
}
}
}
}
}
private static void _getEnumerator_callbacker(BlockCallBackBase sender,object args)
{
StackFrame frame = (StackFrame)sender.args;
rtObjectBase save = (rtObjectBase)sender.step.reg.getValue(sender.scope,frame);
HostedDynamicObject saveObj = (HostedDynamicObject)save.value;
saveObj.hosted_object = frame._tempSlot1.getValue();
((StackFrame)sender.args).endStep(sender.step);
}
public static void enumerator_current(StackFrame frame,OpStep step,RunTimeScope scope)
{
//StackSlot slot = (StackSlot)((Register)step.arg1).getSlot(scope);
rtObjectBase save = (rtObjectBase)(step.arg1).getValue(scope,frame);
HostedDynamicObject saveObj = (HostedDynamicObject)save.value;
IEnumerator <RunTimeValueBase> enumerator = saveObj.hosted_object as IEnumerator <RunTimeValueBase>;
//IEnumerator<RunTimeValueBase> enumerator = scope.cache_enumerator as IEnumerator<RunTimeValueBase>;
if (enumerator != null)
{
step.reg.getSlot(scope,frame).directSet(enumerator.Current);
}
else
{
if (saveObj.hosted_object is rtObjectBase) //是否是接口
{
var movenext = ClassMemberFinder.find(frame.player.swc.IEnumeratorInterface,"current",frame.player.swc.IEnumeratorInterface);
var method =
((ClassPropertyGetter)movenext.bindField).getter.getMethod(((rtObjectBase)saveObj.hosted_object));
//***调用方法***
var funCaller = frame.player.funcCallerPool.create(frame,step.token);
//funCaller.releaseAfterCall = true;
funCaller.SetFunction((ASBinCode.rtData.rtFunction)method); ((ASBinCode.rtData.rtFunction)method).Clear();
funCaller.loadDefineFromFunction();
if (!funCaller.createParaScope())
{
return;
}
funCaller._tempSlot = step.reg.getSlot(scope,frame);
funCaller.returnSlot = step.reg.getSlot(scope,frame);
BlockCallBackBase cb = frame.player.blockCallBackPool.create();
cb.setCallBacker(D_enumerator_operator_callbacker);
cb.step = step;
cb.args = frame;
funCaller.callbacker = cb;
funCaller.call();
return;
}
}
frame.endStep(step);
}
public static StackCacheObject createFrom(StackLinkObjectCache cache, rtObjectBase src)
{
LinkSystemObject lobj = (LinkSystemObject)src.value;
StackCacheObject clone = new StackCacheObject(cache, (lobj).Clone(),
null
);
RunTimeScope scope =
new RunTimeScope(null, src.objScope.blockId, null,
clone, RunTimeScopeType.objectinstance);
clone.objScope = scope;
return(clone);
}
//WeakReference cache;
public override RunTimeValueBase getMethod(rtObjectBase rtObj)
{
//if (cache.IsAlive)
//{
// if ( ReferenceEquals( ((rtFunction)cache.Target).this_pointer , rtObj))
// {
// return (rtFunction)cache.Target;
// }
//}
if (!isNotReadVirtual)
{
var vmember = (ClassMethodGetter)(rtObj).value._class.classMembers[indexofMember].bindField;
//rtData.rtFunction method = new rtData.rtFunction(vmember.functionid, true);
//method.bind(rtObj.objScope);
//method.setThis(rtObj);
//cache.Target = method;
//return method;
_cachemethod.SetValue(vmember.functionid, true);
_cachemethod.bind(rtObj.objScope);
_cachemethod.setThis(rtObj);
return(_cachemethod);
}
else
{
//rtData.rtFunction method = new rtData.rtFunction(functionid, true);
//method.bind(rtObj.objScope);
//method.setThis(rtObj);
//cache.Target = method;
//return method;
_cachemethod.SetValue(functionid, true);
_cachemethod.bind(rtObj.objScope);
_cachemethod.setThis(rtObj);
return(_cachemethod);
}
}
public static void enumerator_close(StackFrame frame,OpStep step,RunTimeScope scope)
{
//StackSlot slot = (StackSlot)((Register)step.arg1).getSlot(scope);
rtObjectBase save = (rtObjectBase)(step.arg1).getValue(scope,frame);
HostedDynamicObject saveObj = (HostedDynamicObject)save.value;
//if (scope.cache_enumerator != null)
{
IEnumerator <RunTimeValueBase> enumerator = saveObj.hosted_object as IEnumerator <RunTimeValueBase>;
if (enumerator != null)
{
enumerator.Dispose();
}
saveObj.hosted_object = null;
}
frame.endStep(step);
}
public sealed override bool directSet(RunTimeValueBase value)
{
if (linktarget != null)
{
return(linktarget.directSet(value));
}
else
{
index = (int)value.rtType;
//if (index > RunTimeDataType.unknown) //若大于unknown,则说明是一个对象
//{
// index = RunTimeDataType._OBJECT;
//}
//值类型必须拷贝!!否则值可能被其他引用而导致错误
//私有构造函数的数据可以直接传引用，否则必须拷贝赋值。
switch (value.rtType)
{
case RunTimeDataType.rt_boolean:
store[0] = value;
break;
case RunTimeDataType.rt_int:
//setValue(((rtInt)value).value);
_intValue.value = ((rtInt)value).value;
break;
case RunTimeDataType.rt_uint:
//setValue(((rtUInt)value).value);
_uintValue.value = ((rtUInt)value).value;
break;
case RunTimeDataType.rt_number:
_numberValue.value = ((rtNumber)value).value;
break;
case RunTimeDataType.rt_string:
setValue(((rtString)value).value);
break;
case RunTimeDataType.rt_void:
store[index] = value;
break;
case RunTimeDataType.rt_null:
store[6] = value;
break;
case RunTimeDataType.rt_function:
{ //Function需要保存上下文环境。因此需要像值类型那样进行拷贝
_functionValue.CopyFrom((rtFunction)value);
//store[index] = _functionValue;
store[COMMREFTYPEOBJ] = _functionValue;
needclear = true; refPropChanged = true;
}
break;
case RunTimeDataType.fun_void:
store[8] = value;
break;
case RunTimeDataType.rt_array:
{
//store[index] = value;
store[COMMREFTYPEOBJ] = value; refPropChanged = true;
}
break;
case RunTimeDataType.unknown:
store[10] = null;
break;
default:
{
index = RunTimeDataType._OBJECT;
rtObjectBase obj = (rtObjectBase)value; refPropChanged = true;
if (obj.value._class.isLink_System)
{
if (obj is StackLinkObjectCache.StackCacheObject)
{
needclear = true;
//链接到系统的对象。这里需要用到缓存的rtObject，以避免当调用链接对象的方法并返回的也是链接对象时，
//要重新创建rtObject,而是直接更新缓存的rtObject.
var cacheobj = _linkObjCache.getCacheObj(obj.value._class);
ASBinCode.rtti.LinkSystemObject link = (ASBinCode.rtti.LinkSystemObject)cacheobj.value;
if (obj.value._class.isStruct)
{
link.CopyStructData((ASBinCode.rtti.LinkSystemObject)obj.value);
}
else
{
link._class = obj.value._class;
link.SetLinkData(((ASBinCode.rtti.LinkSystemObject)obj.value).GetLinkData());
cacheobj.rtType = obj.rtType;
cacheobj.objScope.blockId = obj.value._class.blockid;
}
//rtObject srcObj = ((rtObject)value);
//StackLinkObjectCache.StackCacheObject ss = srcObj as StackLinkObjectCache.StackCacheObject;
//if (ss != null)
//{
// srcObj = ss.getSrcObject();
//}
//if (!(srcObj is StackLinkObjectCache.StackCacheObject))
//{
// //当对象方法调用已绑定了这个槽中的链接对象，然后下面又复用了这个槽时
// //为了避免下面寄存器复用破坏缓存中的LinkSystemObject对象，缓存一份
// _linkObjCache.srcObject = srcObj;
//}
//store[RunTimeDataType._OBJECT] = cacheobj;
store[COMMREFTYPEOBJ] = cacheobj;
}
else
{
store[COMMREFTYPEOBJ] = value;
}
}
else
{
//store[RunTimeDataType._OBJECT] = value;
store[COMMREFTYPEOBJ] = value;
}
}
break;
}
return(true);
}
}
public override bool directSet(RunTimeValueBase value)
{
//value只会在内部new出来，因此，如果value不为null,也肯定是自己new出来的
rtType = value.rtType;
if (this.value == null || this.value.rtType != rtType)
{
//new 一个
this.value = (RunTimeValueBase)value.Clone();
}
else
{
switch (value.rtType)
{
case RunTimeDataType.rt_boolean:
this.value = value;
break;
case RunTimeDataType.rt_int:
((rtInt)this.value).value = ((rtInt)value).value;
break;
case RunTimeDataType.rt_uint:
((rtUInt)this.value).value = ((rtUInt)value).value;
break;
case RunTimeDataType.rt_number:
((rtNumber)this.value).value = ((rtNumber)value).value;
break;
case RunTimeDataType.rt_string:
((rtString)this.value).value = ((rtString)value).value;
break;
case RunTimeDataType.rt_void:
this.value = value;
break;
case RunTimeDataType.rt_null:
this.value = value;
break;
case RunTimeDataType.rt_function:
((rtFunction)this.value).CopyFrom((rtFunction)value);
break;
case RunTimeDataType.fun_void:
this.value = value;
break;
case RunTimeDataType.rt_array:
//((rtArray)this.value).CopyFrom((rtArray)value);
this.value = value;
break;
case RunTimeDataType.unknown:
this.value = null;
break;
default:
if (!ReferenceEquals(this.value,value))
{
rtObjectBase ro = (rtObjectBase)value;
var _class = ro.value._class;
//if (this.value.rtType == value.rtType)//前面已有判断这里肯定相同
{
if (_class.isLink_System)
{
//if (_class.isStruct)
//{
// this.value = (RunTimeValueBase)value.Clone();
//}
//else if (ro is ASRuntime.StackLinkObjectCache.StackCacheObject)
//{
// this.value = (RunTimeValueBase)value.Clone();
//}
//else
//{
// this.value = value;
//}
if (_class.isStruct)
{
((rtti.LinkSystemObject)((rtObjectBase)this.value).value)
.CopyStructData((rtti.LinkSystemObject)ro.value);
}
else if (value is ASRuntime.StackLinkObjectCache.StackCacheObject)
{
this.value = (RunTimeValueBase)value.Clone();
}
else
{
//var dst = ((rtObjectBase)this.value).value;
//var src = ro.value;
//((rtti.LinkObj<object>)dst).SetLinkData(((rtti.LinkObj<object>)src).value);
//((rtObjectBase)this.value).value = ro.value;
this.value = value;
}
}
else
{
this.value = value;
}
}
//else
//{
// this.value = (RunTimeValueBase)value.Clone(); //考虑处理结构类型struct
//}
}
//this.value = (rtObject)value.Clone();
//if (((rtObject)this.value).value.objectid != ((rtObject)value).value.objectid)
//{
//}
//((rtObject)this.value).CopyFrom((rtObject)value);
break;
}
}
return(true);
}
public abstract RunTimeValueBase getMethod(rtObjectBase rtObj);
public static void bind(StackFrame frame, ASBinCode.OpStep step, RunTimeScope scope)
{
var rv = step.arg1.getValue(frame.scope, frame);
if (rv.rtType != RunTimeDataType.rt_function)
{
frame.throwError(
step.token, 0, "value is not a function");
frame.endStep(step);
return;
}
else
{
ASBinCode.rtData.rtFunction function = (ASBinCode.rtData.rtFunction)rv;
if (function.bindScope == null
||
function.bindScope.blockId == frame.scope.blockId
)
{
function.bind(frame.scope);
}
if (!function.ismethod)
{
if (function.this_pointer == null)
{
var s = frame.scope;
if (s.this_pointer != null && s.this_pointer is rtObjectBase)
{
rtObjectBase obj = (rtObjectBase)s.this_pointer;
if (obj.value is Global_Object)
{
function.setThis(obj);
}
else
{
var cls = obj.value._class;
if (cls.staticClass == null)
{
cls = cls.instanceClass;
}
if (cls.mainClass != null)
{
cls = cls.mainClass;
}
var ot = frame.player.outpackage_runtimescope[cls.classid];
function.setThis(ot.this_pointer);
}
}
else
{
if (frame.player.infoOutput != null)
{
frame.player.infoOutput.Warring("当前函数没有this指针。也许不是从文档类启动，而是从包外代码启动的");
}
}
}
}
frame.endStepNoError();
}
}
public static void enumerator_movenext(StackFrame frame,OpStep step,RunTimeScope scope)
{
//StackSlot slot = (StackSlot)((Register)step.arg1).getSlot(scope);
rtObjectBase save = (rtObjectBase)(step.arg1).getValue(scope,frame);
HostedDynamicObject saveObj = (HostedDynamicObject)save.value;
IEnumerator <RunTimeValueBase> enumerator = saveObj.hosted_object as IEnumerator <RunTimeValueBase>;
if (enumerator != null) //&& enumerator.MoveNext() )//slot.cache_enumerator !=null && slot.cache_enumerator.MoveNext())
{
try
{
if (enumerator.MoveNext())
{
step.reg.getSlot(scope,frame).setValue(rtBoolean.True);
}
else
{
step.reg.getSlot(scope,frame).setValue(rtBoolean.False);
}
}
catch (ASRunTimeException ex)
{
step.reg.getSlot(scope,frame).setValue(rtBoolean.False);
frame.throwAneException(step.token,ex.Message + "\n" + ex.AS3StackTrace);
return;
}
}
else
{
if (saveObj.hosted_object is rtObjectBase) //是否是接口
{
var movenext = ClassMemberFinder.find(frame.player.swc.IEnumeratorInterface,"moveNext",frame.player.swc.IEnumeratorInterface);
var method = ((InterfaceMethodGetter)movenext.bindField).getMethod(
(((rtObjectBase)saveObj.hosted_object)));
//***调用方法***
var funCaller = frame.player.funcCallerPool.create(frame,step.token);
//funCaller.releaseAfterCall = true;
funCaller.SetFunction((ASBinCode.rtData.rtFunction)method); ((ASBinCode.rtData.rtFunction)method).Clear();
funCaller.loadDefineFromFunction();
if (!funCaller.createParaScope())
{
return;
}
funCaller._tempSlot = step.reg.getSlot(scope,frame);
funCaller.returnSlot = step.reg.getSlot(scope,frame);
BlockCallBackBase cb = frame.player.blockCallBackPool.create();
cb.setCallBacker(D_enumerator_operator_callbacker);
cb.step = step;
cb.args = frame;
funCaller.callbacker = cb;
funCaller.call();
return;
}
else
{
step.reg.getSlot(scope,frame).setValue(rtBoolean.False);
}
}
frame.endStep(step);
}
public static void foreach_get_enumerator(StackFrame frame,OpStep step,RunTimeScope scope)
{
var player = frame.player;
SLOT slot = step.reg.getSlot(scope,frame);
ASBinCode.rtti.HostedDynamicObject saveObj = new ASBinCode.rtti.HostedDynamicObject(player.swc.ObjectClass);
rtObject save = new rtObject(saveObj,null);
slot.directSet(save);
var obj = step.arg1.getValue(scope,frame);
if (obj.rtType > RunTimeDataType.unknown)
{
rtObjectBase rtObj = (rtObjectBase)obj;
if (ClassMemberFinder.isInherits(rtObj.value._class,
player.swc.primitive_to_class_table[RunTimeDataType.rt_array]))
{
rtArray arr = (rtArray)rtObj.value.memberData[0].getValue();
saveObj.hosted_object = getArrayForEach(arr.innerArray);
}
else if (player.swc.dict_Vector_type.ContainsKey(rtObj.value._class))
{
saveObj.hosted_object = getArrayForEach(((Vector_Data)((HostedObject)rtObj.value).hosted_object).innnerList);
}
else if (ClassMemberFinder.isImplements(rtObj.value._class,player.swc.IEnumerableInterface))
{
//***调用getIEnumerator方法****
var movenext = ClassMemberFinder.find(
frame.player.swc.IEnumerableInterface,"getEnumerator",
frame.player.swc.IEnumerableInterface);
var method = ((InterfaceMethodGetter)movenext.bindField).getMethod(
rtObj);
//***调用方法***
var funCaller = player.funcCallerPool.create(frame,step.token);
//funCaller.releaseAfterCall = true;
funCaller.SetFunction((rtFunction)method); ((rtFunction)method).Clear();
funCaller.loadDefineFromFunction();
if (!funCaller.createParaScope())
{
return;
}
funCaller._tempSlot = frame._tempSlot1;
funCaller.returnSlot = frame._tempSlot1;
BlockCallBackBase cb = frame.player.blockCallBackPool.create();
cb.setCallBacker(D_getEnumerator_callbacker);
cb.step = step;
cb.args = frame;
cb.scope = scope;
funCaller.callbacker = cb;
funCaller.call();
return;
}
else if (ClassMemberFinder.isImplements(
rtObj.value._class,player.swc.IEnumeratorInterface))
{
saveObj.hosted_object = rtObj;
}
else
{
IEnumerator <RunTimeValueBase> forinenum = getForEach_IEnumerator(player,rtObj.value,frame,step,scope);
saveObj.hosted_object = forinenum;
}
}
frame.endStep();
}
public override void clear()
{
setindex = null;
bindObj = null;
}
