private static void objcreated(BlockCallBackBase sender, object args)
{
StackFrame frame = (StackFrame)sender.args;
sender.step.reg.getSlot(sender.scope, frame).directSet(
frame.instanceCreator.objectResult);
frame.deActiveInstanceCreator();
frame.endStep();
}
private void check_para_failed(BlockCallBackBase sender,object args)
{
//清理栈
clear_para_slot(invokerFrame,onstackparametercount); onstackparametercount = 0;
if (callbacker != null)
{
callbacker.noticeRunFailed();
}
release();
}
private static void callfun_cb(BlockCallBackBase sender,object args)
{
IBlockCallBack callbacker = sender.cacheObjects[0] as IBlockCallBack;
StackFrame frame = (StackFrame)sender.cacheObjects[1];
clear_para_slot(frame,sender._intArg);
if (callbacker != null)
{
callbacker.call(callbacker.args);
}
}
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);
}
private void callfun_failed(BlockCallBackBase sender,object args)
{
IBlockCallBack callbacker = sender.cacheObjects[0] as IBlockCallBack;
StackFrame frame = (StackFrame)sender.cacheObjects[1];
clear_para_slot(frame,sender._intArg);
if (callbacker != null)
{
callbacker.noticeRunFailed();
}
}
private static void check_para_failed(BlockCallBackBase sender,object args)
{
FunctionCaller caller = (FunctionCaller)sender.cacheObjects[0];
//清理栈
clear_para_slot(caller.invokerFrame,caller.onstackparametercount); caller.onstackparametercount = 0;
if (caller.callbacker != null)
{
caller.callbacker.noticeRunFailed();
}
caller.release();
}
private static void afterCreateInstanceDataCallBacker(BlockCallBackBase sender,object args)
{
InstanceCreator ic = (InstanceCreator)sender.args;
ASBinCode.rtti.Object obj = (ASBinCode.rtti.Object)sender.cacheObjects[0];
RunTimeScope objScope = (RunTimeScope)sender.cacheObjects[2];
ASBinCode.rtData.rtObjectBase rtObject = (ASBinCode.rtData.rtObjectBase)sender.cacheObjects[1];
ic.toNoticeFailed1 = sender;
ic.exec_step2(obj,objScope,rtObject);
ic.toNoticeFailed1 = null;
}
internal void noticeWhenCreateAneFailed()
{
if (toNoticeFailed1 != null)
{
toNoticeFailed1.noticeRunFailed();
toNoticeFailed1 = null;
}
if (toNoticeFailed2 != null)
{
toNoticeFailed2.noticeRunFailed();
toNoticeFailed2 = null;
}
}
private void _movenext_callbacker(BlockCallBackBase sender,object args)
{
ASBinCode.rtti.YieldObject yieldObj = (ASBinCode.rtti.YieldObject)sender.args;
yieldObj._moveNextResultSlot.directSet(yieldObj.argements[yieldObj.argements.Length - 1].getValue());
yieldObj._moveNextResultSlot = null;
IBlockCallBack cb = ((IBlockCallBack)yieldObj._callbacker);
yieldObj._callbacker = null;
cb.call(cb.args);
}
private void exec_step1()
{
BlockCallBackBase callbacker = player.blockCallBackPool.create();
callbacker.args = this;
callbacker.setCallBacker(afterCreateInstanceDataCallBacker);
callbacker.setWhenFailed(creatorFailed);
ASBinCode.RunTimeScope objScope;
makeObj(player,token,_class,callbacker,this,out objScope);
}
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 override void executeAsync(RunTimeValueBase thisObj,SLOT[] argements,SLOT resultSlot,object callbacker,object stackframe,SourceToken token,RunTimeScope scope)
{
IBlockCallBack cb = (IBlockCallBack)callbacker;
StackFrame frame = (StackFrame)stackframe;
if (argements[0].getValue().rtType == RunTimeDataType.rt_null)
{
if (frame.player.infoOutput != null)
{
frame.player.infoOutput.Info(string.Empty);
}
cb.call(cb.args);
return;
}
rtArray array = (rtArray)(argements[0].getValue());
if (array.innerArray.Count == 0)
{
if (frame.player.infoOutput != null)
{
frame.player.infoOutput.Info(string.Empty);
}
cb.call(cb.args);
return;
}
BlockCallBackBase sepcb = frame.player.blockCallBackPool.create();
sepcb.scope = scope;
sepcb._intArg = 0;
sepcb.setCallBacker(null);
sepcb._intArg2 = 0;
object[] sendargs = sepcb.cacheObjects;
sendargs[0] = cb;
sendargs[1] = array;
sendargs[2] = frame;
sendargs[3] = token;
sendargs[4] = scope;
sendargs[5] = " ";
sendargs[6] = new StringBuilder();
sendargs[7] = resultSlot;
//sendargs[8] = new rtInt(0);
sepcb.args = sendargs;
_SeptoString_CB(sepcb,sendargs);
}
private void check_para_callbacker(BlockCallBackBase sender,object args)
{
if (sender.isSuccess)
{
//CallFuncHeap[sender._intArg].directSet(_tempSlot.getValue());
setCheckedParameter(sender._intArg,_tempSlot.getValue());
check_para(sender);
}
else
{
throw new ASRunTimeException("解释器内部错误，参数类型检查",string.Empty);
//invokerFrame.throwCastException(token, ((RunTimeValueBase)sender.args).rtType, toCallFunc.signature.parameters[sender._intArg].type);
//return;
}
}
private static void creatorFailed(BlockCallBackBase sender,object args)
{
InstanceCreator ic = (InstanceCreator)args;
if (ic.constructorCaller != null)
{
ic.constructorCaller.noticeRunFailed();
ic.constructorCaller = null;
}
if (ic.callbacker != null)
{
ic.callbacker.noticeRunFailed();
ic.callbacker = null;
}
}
public static void exec_instanceClass(StackFrame frame, ASBinCode.OpStep step, ASBinCode.RunTimeScope scope)
{
//frame.instanceCreator.objectResult = step.reg.getISlot(scope);
frame.instanceCreator.step = step;
frame.instanceCreator.token = step.token;
frame.instanceCreator.objectStoreToSlot = step.reg.getSlot(scope, frame);
BlockCallBackBase cb = frame.player.blockCallBackPool.create();
cb.args = frame;
cb.setCallBacker(D_objcreated);
cb.scope = scope;
cb.step = step;
frame.instanceCreator.callbacker = cb;
frame.instanceCreator.createInstance();
}
public override void executeAsync(RunTimeValueBase thisObj,SLOT[] argements,
SLOT resultSlot,object callbacker,object stackframe,SourceToken token,RunTimeScope scope)
{
IBlockCallBack cb = (IBlockCallBack)callbacker;
StackFrame frame = (StackFrame)stackframe;
rtArray array = (rtArray)((rtObjectBase)thisObj).value.memberData[0].getValue();
if (array.innerArray.Count == 0)
{
cb.call(cb.args);
resultSlot.directSet(new rtString(string.Empty));
return;
}
BlockCallBackBase sepcb = frame.player.blockCallBackPool.create();
sepcb.scope = scope;
sepcb._intArg = 0;
object[] sendargs = sepcb.cacheObjects;
sendargs[0] = cb;
sendargs[1] = array;
sendargs[2] = frame;
sendargs[3] = token;
sendargs[4] = scope;
sendargs[5] = argements[0].getValue();
sendargs[6] = new StringBuilder();
sendargs[7] = resultSlot;
sendargs[8] = new rtInt(0);
sepcb.args = sendargs;
sepcb.setCallBacker(D_SeptoString_CB);
operators.OpCast.CastValue(argements[0].getValue(),RunTimeDataType.rt_string,
frame,token,scope,frame._tempSlot1,sepcb,false);
}
public static void exec(StackFrame frame, ASBinCode.OpStep step, ASBinCode.RunTimeScope scope)
{
//int classid = ((ASBinCode.rtData.rtInt)step.arg1.getValue(scope)).value;
//ASBinCode.rtti.Class as3class = player.swc.classes[classid];
//exec_createinstance(as3class, player, frame, step, scope);
//frame.instanceCreator.objectResult = step.reg.getISlot(scope);
frame.instanceCreator.step = step;
frame.instanceCreator.token = step.token;
frame.instanceCreator.objectStoreToSlot = step.reg.getSlot(scope, frame);
BlockCallBackBase cb = frame.player.blockCallBackPool.create();
cb.args = frame;
cb.setCallBacker(D_objcreated);
cb.scope = scope;
cb.step = step;
frame.instanceCreator.callbacker = cb;
frame.instanceCreator.createInstance();
}
public static void execUnaryPlus(StackFrame frame, ASBinCode.OpStep step, ASBinCode.RunTimeScope scope)
{
ASBinCode.RunTimeValueBase v = step.arg1.getValue(scope, frame);
var f = frame.player.swc.operatorOverrides.getOperatorFunction(OverrideableOperator.Unary_plus,
v.rtType, RunTimeDataType.unknown);
if (f != null)
{
FunctionCaller fc = frame.player.funcCallerPool.create(frame, step.token); //fc.releaseAfterCall = true;
fc.SetFunction(f);
fc.loadDefineFromFunction();
if (!fc.createParaScope())
{
return;
}
bool success;
fc.pushParameter(v, 0, out success);
fc.returnSlot = step.reg.getSlot(scope, frame);
fc.callbacker = fc;
fc.call();
return;
}
else
{
BlockCallBackBase cb = frame.player.blockCallBackPool.create();
cb.scope = scope;
cb.step = step;
cb.args = frame;
cb.setCallBacker(_tonumber_cb);
OpCast.CastValue(v, RunTimeDataType.rt_number,
frame, step.token, scope, frame._tempSlot1, cb, false);
}
}
public static void pushAllElementToVector(ASBinCode.rtti.Vector_Data vd,
List <RunTimeValueBase> datalist, StackFrame frame, SourceToken token,
RunTimeScope scope,
IBlockCallBack callbacker
)
{
BlockCallBackBase convertCb = frame.player.blockCallBackPool.create();
convertCb._intArg = 0;
convertCb.setCallBacker(_convertCB);
object[] args = convertCb.cacheObjects; //new object[6];
args[0] = vd;
args[1] = datalist;
args[2] = token;
args[3] = scope;
args[4] = callbacker;
args[5] = frame;
convertCb.args = args;
OpCast.CastValue(datalist[convertCb._intArg],
vd.vector_type, frame, token, scope, frame._tempSlot1,
convertCb, false);
}
private static void afterCreateOutScopeCallbacker(BlockCallBackBase sender,object args)
{
((InstanceCreator)sender.args).
exec_step1();
}
private static void afterCreateStaticInstanceCallBacker(BlockCallBackBase sender,object args)
{
InstanceCreator ic = (InstanceCreator)sender.args;
ic.set_Class_constructor();
}
private void exec_step2(
ASBinCode.rtti.Object obj,
RunTimeScope objScope,ASBinCode.rtData.rtObjectBase _object)
{
//***添加Object的动态对象****
if (
//(obj._class.classid == 0)
obj is DynamicObject &&
obj._class.staticClass != null)
{
DynamicObject dobj = (DynamicObject)obj;
if (constructor == null)
{
dobj.createproperty("constructor",new DynamicPropertySlot(_object,false,player.swc.FunctionClass.getRtType()));
dobj["constructor"].directSet(player.static_instance[obj._class.staticClass.classid]);
dobj._prototype_ = (DynamicObject)player.static_instance[_class.staticClass.classid].value;
}
else
{
dobj._prototype_ = (DynamicObject)constructor.value;
}
}
ClassMember ctor = obj._class.constructor;
//if (obj._class.isCrossExtend)
//{
// //***创建Adapter***
// var scls = obj._class.super;
// while (!scls.isLink_System)
// {
// scls = scls.super;
// }
// ctor = scls.crossExtendAdapterCreator;
// var nf = player.swc.getNativeFunction(((MethodGetterBase)ctor.bindField).functionId);
// if (!(nf is ICrossExtendAdapterCreator))
// {
// invokerFrame.throwAneException(token, "adapter不是ICrossExtendAdapterCreator");
// callbacker.noticeRunFailed();
// noticeWhenCreateAneFailed();
// invokerFrame.endStep();
// return;
// }
// constructorCaller.toCallFunc = player.swc.functions[((MethodGetterBase)ctor.bindField).functionId];
//}
//调用构造函数
if (ctor != null)
{
ASBinCode.rtData.rtFunction function =
(ASBinCode.rtData.rtFunction)((MethodGetterBase)ctor.bindField).getConstructor(objScope);
HeapSlot _temp = tempSlot;
constructorCaller.returnSlot = _temp;
constructorCaller.SetFunction(function); function.Clear();
//afterCallConstructor callbacker = new afterCallConstructor();
var callbacker = player.blockCallBackPool.create();
callbacker.args = this;
//callbacker.obj = obj;
//callbacker.objScope = objScope;
//callbacker.rtObject = _object;
callbacker.cacheObjects[0] = _object;
callbacker.setWhenFailed(creatorFailed);
callbacker.setCallBacker(afterCallConstructorCallbacker);
constructorCaller.callbacker = callbacker;
toNoticeFailed2 = callbacker;
constructorCaller.call();
toNoticeFailed2 = null;
constructorCaller = null;
}
else
{
exec_step3(_object);
}
}
private static ASBinCode.rtData.rtObjectBase makeObj(
Player player,
SourceToken token,
ASBinCode.rtti.Class cls,
BlockCallBackBase callbacker,InstanceCreator creator,out ASBinCode.RunTimeScope objScope)
{
ASBinCode.rtData.rtObjectBase result; ASBinCode.rtData.rtObjectBase lr; string err;
ASBinCode.rtti.Object obj = createObject(player.swc,cls,creator,out result,out lr,out err);
if (obj == null)
{
objScope = null;
if (callbacker != null)
{
callbacker.noticeRunFailed();
}
player.throwWhenMakeObjFailed(new ASRunTimeException(err,player.stackTrace(0)));
return(null);
}
if (result == null)
{
if (lr == null)
{
result = new ASBinCode.rtData.rtObject(obj,null);
}
else
{
result = lr;
}
if (cls.fields.Count > 0)
{
obj.memberData = new ObjectMemberSlot[cls.fields.Count];
for (int i = 0; i < obj.memberData.Length; i++)
{
obj.memberData[i] = new ObjectMemberSlot(result,player.swc.FunctionClass.getRtType(),cls.fields[i].valueType,player.swc);
if (cls.fields[i].defaultValue == null)
{
obj.memberData[i].directSet(TypeConverter.getDefaultValue(cls.fields[i].valueType).getValue(null,null));
}
((ObjectMemberSlot)obj.memberData[i]).isConstMember = cls.fields[i].isConst;
}
}
else
{
obj.memberData = blankFields;
}
ASBinCode.CodeBlock codeblock = player.swc.blocks[cls.blockid];
objScope = player.callBlock(codeblock,
(ObjectMemberSlot[])obj.memberData,null,
null
,token,callbacker
,
result,RunTimeScopeType.objectinstance
);
result.objScope = objScope;
if (objScope == null)
{
if (callbacker != null)
{
callbacker.noticeRunFailed();
}
return(null);
}
//***把父类的初始化函数推到栈上去***
var ss = cls.super;
while (ss != null)
{
var scope = player.callBlock(player.swc.blocks[ss.blockid],
(ObjectMemberSlot[])obj.memberData,
null,null,token,null,result,RunTimeScopeType.objectinstance
);
ss = ss.super;
if (scope == null)
{
if (callbacker != null)
{
callbacker.noticeRunFailed();
}
return(null);
}
}
}
else
{
objScope = result.objScope;
player.CallBlankBlock(callbacker);
}
if (callbacker != null)
{
//callbacker.obj = obj;
//callbacker.rtObject = result;
//callbacker.objScope = objScope;
callbacker.cacheObjects[0] = obj;
callbacker.cacheObjects[1] = result;
callbacker.cacheObjects[2] = objScope;
}
return(result);
}
public static void _do_prop_read(
ClassPropertyGetter prop,StackFrame frame,OpStep step,Player player,RunTimeScope scope,
ASBinCode.rtData.rtObjectBase propBindObj,Class superPropBindClass
)
{
do
{
//***调用访问器。***
if (prop.getter == null)
{
frame.throwError(
step.token,0,"Illegal read of write-only property"
);
break;
}
//检查访问权限
CodeBlock block = player.swc.blocks[scope.blockId];
Class finder;
if (block.isoutclass)
{
var c = prop._class;
if (c.instanceClass != null)
{
c = c.instanceClass;
}
if (c.mainClass != null)
{
c = c.mainClass;
}
if (block.define_class_id == c.classid)
{
finder = player.swc.classes[block.define_class_id];
}
else
{
finder = null;
}
}
else
{
finder = player.swc.classes[block.define_class_id];
}
var getter = ClassMemberFinder.find(prop._class,prop.getter.name,finder);
if (getter == null || getter.bindField != prop.getter)
{
frame.throwError(
step.token,0,"Illegal read of write-only property"
);
break;
}
//***读取getter***
RunTimeValueBase func;
if (superPropBindClass != null)
{
func = ((MethodGetterBase)getter.bindField).getSuperMethod(
//propslot.bindObj.objScope
propBindObj.objScope,
superPropBindClass
);
}
else
{
func = ((MethodGetterBase)getter.bindField).getMethod(
//propslot.bindObj.objScope
propBindObj
);
}
//***调用访问器***
var funCaller = player.funcCallerPool.create(frame,step.token);
//funCaller.releaseAfterCall = true;
funCaller.SetFunction((ASBinCode.rtData.rtFunction)func); ((ASBinCode.rtData.rtFunction)func).Clear();
funCaller.loadDefineFromFunction();
if (!funCaller.createParaScope())
{
return;
}
funCaller._tempSlot = frame._tempSlot1;
funCaller.returnSlot = step.reg.getSlot(scope,frame);
((StackSlot)funCaller.returnSlot).stackObjects.propGetSet = prop; ((StackSlot)funCaller.returnSlot).refPropChanged = true;
((StackSlot)funCaller.returnSlot).stackObjects.propBindObj = propBindObj;
BlockCallBackBase cb = frame.player.blockCallBackPool.create();
cb.setCallBacker(D_getter_callbacker);
cb.step = step;
cb.args = frame;
funCaller.callbacker = cb;
funCaller.call();
return;
} while (false);
frame.endStep(step);
}
private void check_para(BlockCallBackBase checkparacb)
{
while (check_para_id < pushedArgs)
{
var parameter = toCallFunc.signature.parameters;
RunTimeValueBase argement = getToCheckParameter(check_para_id);
var argtype = argement.rtType;
var targettype = parameter[check_para_id].type;
if (argtype != targettype
&&
targettype != RunTimeDataType.rt_void
&&
!(argtype == RunTimeDataType.rt_null && targettype > RunTimeDataType.unknown)
&&
!(argtype > RunTimeDataType.unknown && targettype > RunTimeDataType.unknown
&&
(
ClassMemberFinder.check_isinherits(argement,targettype,player.swc)
||
ClassMemberFinder.check_isImplements(argement,targettype,player.swc)
)
)
)
{
BlockCallBackBase cb = player.blockCallBackPool.create();
cb.args = argement;
cb._intArg = check_para_id;
cb.setCallBacker(check_para_callbacker);
cb.setWhenFailed(check_para_failed);
check_para_id++;
OpCast.CastValue(argement,parameter[
cb._intArg].type,
invokerFrame,token,invokerFrame.scope,_tempSlot,cb,false);
return;
}
else
{
check_para_id++;
}
}
if (pushedArgs < toCallFunc.signature.parameters.Count && !toCallFunc.IsAnonymous) //匿名函数能跳过参数检查
{
for (int i = pushedArgs; i < toCallFunc.signature.parameters.Count; i++)
{
if (toCallFunc.signature.parameters[pushedArgs].defaultValue == null
&&
!toCallFunc.signature.parameters[pushedArgs].isPara
)
{
invokerFrame.throwArgementException(
token,
string.Format(
"Argument count mismatch on Function/{0}. Expected {1}, got {2}.",
player.swc.blocks[toCallFunc.blockid].name,toCallFunc.signature.parameters.Count,pushedArgs
)
);
clear_para_slot(invokerFrame,onstackparametercount); onstackparametercount = 0;
//***中断本帧本次代码执行进入try catch阶段
invokerFrame.endStep();
if (callbacker != null)
{
callbacker.noticeRunFailed();
}
release();
return;
}
}
}
if (!check_return_objtypeisclasscreated())
{
return;
}
if (checkparacb != null)
{
checkparacb.noticeEnd();
}
//***全部参数检查通过***
doCall_allcheckpass();
}
public static void execAssigning(StackFrame frame, ASBinCode.OpStep step, ASBinCode.RunTimeScope scope)
{
ASBinCode.SLOT slot = step.reg.getSlotForAssign(scope,frame);
ASBinCode.RunTimeValueBase v = step.arg1.getValue(scope,frame);
bool success;
var lt = slot.assign(v,out success);
if (!success) //(!slot.directSet(v))
{
if (!(slot is StackSlot)) //直接赋值时
{
//ext = "Illegal assignment to function " + ((MethodGetterBase)step.reg).name + ".";
}
else
{
StackSlot oslot = (StackSlot)slot;
//if (oslot.linktarget != null)
{
//slot = oslot.linktarget;
slot = lt;
}
if (step.arg1 is IMemReg)
{
//将其暂存到临时槽内
frame._tempSlot2.directSet(v);
v = frame._tempSlot2.getValue();
}
if (slot is SetThisItemSlot)
{
_doSetThisItem(((SetThisItemSlot)slot).bindObj,v,((SetThisItemSlot)slot).setindex,oslot,frame,step);
return;
}
if (slot is ClassPropertyGetter.PropertySlot)
{
ClassPropertyGetter.PropertySlot propslot =
(ASBinCode.ClassPropertyGetter.PropertySlot)slot;
//***调用访问器。***
ASBinCode.ClassPropertyGetter prop = oslot.stackObjects.propGetSet; //propslot.property;
_doPropAssigning(prop,frame,step,frame.player,scope,
//propslot.bindObj
oslot.stackObjects.propBindObj
,v,
oslot
);
return;
}
if (slot is OpVector.vectorSLot) //Vector类型不匹配
{
BlockCallBackBase cb = frame.player.blockCallBackPool.create();
cb.scope = scope;
cb.step = step;
cb.args = frame;
cb.setCallBacker(_vectorConvertCallBacker);
cb.cacheObjects[0] = slot;
//***调用强制类型转换***
OpCast.CastValue(v,((OpVector.vectorSLot)slot).vector_data.vector_type,
frame,step.token,scope,frame._tempSlot1,cb,false);
return;
}
if (slot is ObjectMemberSlot && !((ObjectMemberSlot)slot).isConstMember)
{
BlockCallBackBase cb = frame.player.blockCallBackPool.create();
cb.scope = scope;
cb.step = step;
cb.args = frame;
cb.setCallBacker(_objectmemberslotConvertCallbacker);
cb.cacheObjects[0] = slot;
//***调用强制类型转换***
OpCast.CastValue(v,((ObjectMemberSlot)slot).slottype,
frame,step.token,scope,frame._tempSlot1,cb,false);
return;
}
}
string ext = String.Empty;
if (slot is MethodGetterBase.MethodSlot)
{
ext = "Cannot assign to a method "; // + ((ASBinCode.ClassMethodGetter.MethodSlot)slot).method;
}
else if (slot is ObjectMemberSlot)
{
ext = "Illegal write to read-only property ";
//+ ((ObjectMemberSlot)slot).obj.value._class.name
//+" on ppp.PPC."
}
else if (slot is ClassPropertyGetter.PropertySlot)
{
ext = "Illegal write to read-only property ";
}
else if (slot is OpAccess_Dot.prototypeSlot)
{
ext = "Cannot create property "
+ ((OpAccess_Dot.prototypeSlot)slot)._protoname +
" on " + ((OpAccess_Dot.prototypeSlot)slot)._protoRootObj.value._class.name;
}
frame.throwError(
step.token,0,ext
);
frame.endStep(step);
}
else
{
frame.endStepNoError();
}
}
internal void doCall_allcheckpass()
{
if (toCallFunc.isYield)
{
if (!player.static_instance.ContainsKey(player.swc.YieldIteratorClass.staticClass.classid))
{
if (!InstanceCreator.init_static_class(player.swc.YieldIteratorClass,player,token))
{
invokerFrame.endStep();
if (callbacker != null)
{
callbacker.noticeRunFailed();
}
release();
return;
}
}
ASBinCode.rtti.YieldObject yobj = new ASBinCode.rtti.YieldObject(
player.swc.YieldIteratorClass);
CallFuncHeap[CallFuncHeap.Length - 2].directSet(new ASBinCode.rtData.rtInt(1));
yobj.argements = CallFuncHeap;
yobj.function_bindscope = function.bindScope;
yobj.block = player.swc.blocks[toCallFunc.blockid];
yobj.yield_function = toCallFunc;
ASBinCode.rtData.rtObject rtYield = new ASBinCode.rtData.rtObject(yobj,null);
yobj.thispointer =
(function.this_pointer != null ?
function.this_pointer : invokerFrame.scope.this_pointer);
RunTimeScope scope = new RunTimeScope(null,
player.swc.YieldIteratorClass.blockid,null,rtYield,RunTimeScopeType.objectinstance);
rtYield.objScope = scope;
returnSlot.directSet(rtYield);
if (callbacker != null)
{
callbacker.call(callbacker.args);
}
release();
return;
}
else if (!toCallFunc.isNative)
{
if (returnSlot is StackSlot)
{
TypeConverter.setDefaultValueToStackSlot(
toCallFunc.signature.returnType,
(StackSlot)returnSlot);
}
else
{
returnSlot.directSet(
TypeConverter.getDefaultValue(toCallFunc.signature.returnType).getValue(null,null));
}
if (!ReferenceEquals(callbacker,this))
{
//***执行完成后，先清理参数***
BlockCallBackBase cb = player.blockCallBackPool.create();
cb.args = cb.cacheObjects;
cb.cacheObjects[0] = callbacker;
cb.cacheObjects[1] = invokerFrame;
cb.setCallBacker(callfun_cb);
cb.setWhenFailed(callfun_failed);
cb._intArg = onstackparametercount;
onstackparametercount = 0;
player.callBlock(
player.swc.blocks[toCallFunc.blockid],
CallFuncHeap,
returnSlot,
function.bindScope,
token,cb,function.this_pointer != null ? function.this_pointer : invokerFrame.scope.this_pointer,RunTimeScopeType.function);
release();
}
else
{
player.callBlock(
player.swc.blocks[toCallFunc.blockid],
CallFuncHeap,
returnSlot,
function.bindScope,
token,callbacker,function.this_pointer != null ? function.this_pointer : invokerFrame.scope.this_pointer,RunTimeScopeType.function);
}
}
else
{
//if (toCallFunc.native_index <0)
//{
// toCallFunc.native_index = player.swc.nativefunctionNameIndex[toCallFunc.native_name];
//}
//var nf = player.swc.nativefunctions[toCallFunc.native_index];
var nf = player.swc.getNativeFunction(toCallFunc);
nf.bin = player.swc;
if (nf.mode == NativeFunctionBase.NativeFunctionMode.normal_0)
{
player._nativefuncCaller = this;
string errormsg;
int errorno;
var result = nf.execute(
function.this_pointer != null ? function.this_pointer : invokerFrame.scope.this_pointer,
CallFuncHeap,invokerFrame,
out errormsg,
out errorno
);
player._nativefuncCaller = null;
if (errormsg == null)
{
returnSlot.directSet(result);
if (callbacker != null)
{
callbacker.call(callbacker.args);
}
release();
}
else
{
invokerFrame.throwError(
token,0,errormsg
);
invokerFrame.endStep();
if (callbacker != null)
{
callbacker.noticeRunFailed();
}
release();
}
}
//else if (nf.mode == NativeFunctionBase.NativeFunctionMode.normal_1)
//{
// player._nativefuncCaller = this;
// bool success;
// nf.execute2(
// function.this_pointer != null ? function.this_pointer : invokerFrame.scope.this_pointer,
// toCallFunc,
// CallFuncHeap,
// returnSlot,
// token,
// invokerFrame,
// out success
// );
// player._nativefuncCaller = null;
// if (success)
// {
// if (callbacker != null)
// {
// callbacker.call(callbacker.args);
// }
// }
// else
// {
// invokerFrame.endStep();
// if (callbacker != null)
// {
// callbacker.noticeRunFailed();
// }
// }
// release();
//}
else if (nf.mode == NativeFunctionBase.NativeFunctionMode.async_0)
{
nf.executeAsync(function.this_pointer != null ? function.this_pointer : invokerFrame.scope.this_pointer,
CallFuncHeap,
returnSlot,
callbacker,
invokerFrame,
token,
function.bindScope
);
if (!ReferenceEquals(callbacker,this))
{
release();
}
}
else if (nf.mode == NativeFunctionBase.NativeFunctionMode.const_parameter_0)
{
bool success = false;
player._nativefuncCaller = this;
var nf3 = (nativefuncs.NativeConstParameterFunction)nf;
player._executeToken = nf3.getExecToken(toCallFunc.functionid);
nf3.execute3(
function.this_pointer != null ? function.this_pointer : invokerFrame.scope.this_pointer,
toCallFunc,
returnSlot,
token,
invokerFrame,
out success
);
player._executeToken = nativefuncs.NativeConstParameterFunction.ExecuteToken.nulltoken;
player._nativefuncCaller = null;
((nativefuncs.NativeConstParameterFunction)nf).clearParameter();
clear_para_slot(invokerFrame,onstackparametercount);
onstackparametercount = 0;
if (success)
{
var receive_err = player.clear_nativeinvokeraiseerror();
if (receive_err != null)
{
invokerFrame.receiveErrorFromStackFrame(receive_err);
if (callbacker != null)
{
callbacker.noticeRunFailed();
}
}
else if (callbacker != null)
{
callbacker.call(callbacker.args);
}
}
else
{
invokerFrame.endStep();
if (callbacker != null)
{
callbacker.noticeRunFailed();
}
}
release();
}
}
}
public static void _doPropAssigning(ClassPropertyGetter prop,StackFrame frame,
OpStep step,Player player,RunTimeScope scope,
ASBinCode.rtData.rtObjectBase bindobj,RunTimeValueBase v,StackSlot sslot)
{
do
{
if (prop.setter == null)
{
frame.throwError(
step.token,0,"Illegal write to read-only property "
);
break;
}
//检查访问权限
CodeBlock block = player.swc.blocks[scope.blockId];
Class finder;
if (block.isoutclass)
{
var c = prop._class;
if (c.instanceClass != null)
{
c = c.instanceClass;
}
if (c.mainClass != null)
{
c = c.mainClass;
}
if (block.define_class_id == c.classid)
{
finder = player.swc.classes[block.define_class_id];
}
else
{
finder = null;
}
}
else
{
finder = player.swc.classes[block.define_class_id];
}
var setter = ClassMemberFinder.find(prop._class,prop.setter.name,finder);
if (setter == null || setter.bindField != prop.setter)
{
frame.throwError(
step.token,0,"Illegal write to read-only property "
);
break;
}
//***读取setter***
RunTimeValueBase func;
if (sslot.stackObjects.superPropBindClass != null)
{
func = ((MethodGetterBase)setter.bindField).getSuperMethod(
bindobj.objScope,
sslot.stackObjects.superPropBindClass
);
}
else
{
func = ((MethodGetterBase)setter.bindField).getMethod(
bindobj
);
}
//***调用设置器***
var funCaller = frame.player.funcCallerPool.create(frame,step.token);
funCaller.SetFunction((ASBinCode.rtData.rtFunction)func); ((ASBinCode.rtData.rtFunction)func).Clear();
funCaller.loadDefineFromFunction();
if (!funCaller.createParaScope())
{
return;
}
//funCaller.releaseAfterCall = true;
bool success;
funCaller.pushParameter(v,0,out success);
if (!success)
{
frame.endStep(step);
return;
}
funCaller._tempSlot = frame._tempSlot1;
funCaller.returnSlot = frame._tempSlot1;
BlockCallBackBase cb = frame.player.blockCallBackPool.create();
cb.setCallBacker(_assign_callbacker);
cb.step = step;
cb.args = frame;
funCaller.callbacker = cb;
funCaller.call();
return;
} while (false);
frame.endStep(step);
}
private void _ValueToString_CB(BlockCallBackBase sender,object args)
{
object[] receiveArgs = (object[])sender.args;
StackFrame frame = (StackFrame)receiveArgs[2];
rtArray array = (rtArray)receiveArgs[1];
//((rtInt)receiveArgs[8]).value++;
sender._intArg2++;
if (sender._intArg2 == 10) //((rtInt)receiveArgs[8]).value == 10) //堆栈清理,防止溢出...
{
sender._intArg2 = 0; //((rtInt)receiveArgs[8]).value = 0;
BlockCallBackBase valueCB = frame.player.blockCallBackPool.create();
valueCB._intArg = sender._intArg; valueCB._intArg2 = 0;
valueCB.args = valueCB.copyFromReceiveArgs(receiveArgs);
valueCB.setCallBacker(_ValueToString_CB);
frame.player.CallBlankBlock(valueCB);
return;
}
StringBuilder sb = (StringBuilder)receiveArgs[6];
SourceToken token = (SourceToken)receiveArgs[3];
string aSep = (string)receiveArgs[5];
sb.Append(
TypeConverter.ConvertToString(frame._tempSlot1.getValue(),frame,token) == null?"null":
TypeConverter.ConvertToString(frame._tempSlot1.getValue(),frame,token)
);
if (sender._intArg < array.innerArray.Count)
{
sb.Append(aSep);
BlockCallBackBase valueCB = frame.player.blockCallBackPool.create();
valueCB._intArg = sender._intArg + 1; valueCB._intArg2 = sender._intArg2;
valueCB.args = valueCB.copyFromReceiveArgs(receiveArgs);
valueCB.setCallBacker(_ValueToString_CB);
var v = array.innerArray[sender._intArg];
if (v.rtType == RunTimeDataType.rt_void)
{
v = UNDEFINED;
}
operators.OpCast.CastValue(v,RunTimeDataType.rt_string,
frame,
(SourceToken)receiveArgs[3],
(RunTimeScope)receiveArgs[4],
frame._tempSlot1,
valueCB,false
);
}
else
{
//ISLOT result = (ISLOT)receiveArgs[7];
//result.directSet(new rtString(sb.ToString()));
if (frame.player.infoOutput != null)
{
frame.player.infoOutput.Info(sb.ToString());
}
IBlockCallBack cb = (IBlockCallBack)receiveArgs[0];
cb.call(cb.args);
}
}
private static void _setthisitem_callbacker(BlockCallBackBase sender,object args)
{
((StackFrame)sender.args).endStep(sender.step);
}
