public bool prepareConstructorArgements() { int classid = _class.classid; ASBinCode.rtti.FunctionDefine funcDefine = player.swc.functions[player.swc.classes[classid].constructor_functionid]; ASBinCode.rtti.FunctionSignature signature = funcDefine.signature; constructorCaller = player.funcCallerPool.create(invokerFrame,token); constructorCaller.toCallFunc = funcDefine; constructorCaller._tempSlot = invokerFrame._tempSlot1; if (!constructorCaller.createParaScope()) { return(false); } //constructorCaller.releaseAfterCall = true; if (constructor != null) { _function_constructor = player.funcCallerPool.create(invokerFrame,token); _function_constructor._tempSlot = invokerFrame._tempSlot1; _function_constructor.toCallFunc = player.swc.functions[((ASBinCode.rtData.rtFunction) TypeConverter.ObjectImplicit_ToPrimitive(constructor)).functionId]; if (!_function_constructor.createParaScope()) { return(false); } //_function_constructor.releaseAfterCall = true; } return(true); }
public static void execBitOR(StackFrame frame, ASBinCode.OpStep step, ASBinCode.RunTimeScope scope) { ASBinCode.RunTimeValueBase v1 = step.arg1.getValue(scope, frame); ASBinCode.RunTimeValueBase v2 = step.arg2.getValue(scope, frame); var f = frame.player.swc.operatorOverrides.getOperatorFunction(OverrideableOperator.bitOr, v1.rtType, v2.rtType); if (f != null) { FunctionCaller fc = frame.player.funcCallerPool.create(frame, step.token); fc.SetFunction(f); fc.loadDefineFromFunction(); if (!fc.createParaScope()) { return; } //fc.releaseAfterCall = true; bool success; fc.pushParameter(v1, 0, out success); fc.pushParameter(v2, 1, out success); fc.returnSlot = step.reg.getSlot(scope, frame); fc.callbacker = fc; fc.call(); } else { OpCast.InvokeTwoValueOf(v1, v2, frame, step.token, scope, frame._tempSlot1, frame._tempSlot2, step, _BitOR_ValueOf_CallBacker); } }
private void exec_step3(ASBinCode.rtData.rtObjectBase rtobject) { if (constructor == null) { objectResult = rtobject; //objectResult.directSet(rtobject); if (callbacker != null) { callbacker.call(this); callbacker = null; } } else { HeapSlot _temp = tempSlot; _temp.directSet(ASBinCode.rtData.rtUndefined.undefined); _function_constructor.returnSlot = _temp; //_function_constructor.function = (ASBinCode.rtData.rtFunction)TypeConverter.ObjectImplicit_ToPrimitive(constructor).Clone(); //_function_constructor.function.setThis(rtobject); _function_constructor.SetFunction((ASBinCode.rtData.rtFunction)TypeConverter.ObjectImplicit_ToPrimitive(constructor),rtobject); BlockCallBackBase cb = player.blockCallBackPool.create(); cb.args = cb.cacheObjects; //new object[] { rtobject , _temp }; cb.cacheObjects[0] = rtobject; cb.cacheObjects[1] = _temp; cb.setCallBacker(_finalStep); _function_constructor.callbacker = cb; _function_constructor.call(); _function_constructor = null; } }
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(); }
public static void execAdd(StackFrame frame, ASBinCode.OpStep step, ASBinCode.RunTimeScope scope) { ASBinCode.RunTimeValueBase v1 = step.arg1.getValue(scope, frame); ASBinCode.RunTimeValueBase v2 = step.arg2.getValue(scope, frame); var f = frame.player.swc.operatorOverrides.getOperatorFunction(OverrideableOperator.addition, v1.rtType, v2.rtType); if (f != null) { FunctionCaller fc = frame.player.funcCallerPool.create(frame, step.token); fc.SetFunction(f); fc.loadDefineFromFunction(); if (!fc.createParaScope()) { return; } //fc.releaseAfterCall = true; bool success; fc.pushParameter(v1, 0, out success); fc.pushParameter(v2, 1, out success); fc.returnSlot = step.reg.getSlot(scope, frame); fc.callbacker = fc; fc.call(); } else if ( (v1.rtType > ASBinCode.RunTimeDataType.unknown && v2.rtType > ASBinCode.RunTimeDataType.unknown) || v1.rtType == ASBinCode.RunTimeDataType.rt_int || v1.rtType == ASBinCode.RunTimeDataType.rt_uint || v1.rtType == ASBinCode.RunTimeDataType.rt_number || v2.rtType == ASBinCode.RunTimeDataType.rt_int || v2.rtType == ASBinCode.RunTimeDataType.rt_uint || v2.rtType == ASBinCode.RunTimeDataType.rt_number ) { OpCast.InvokeTwoValueOf(v1, v2, frame, step.token, scope, frame._tempSlot1, frame._tempSlot2, step, _execAdd_CallBacker); } else //toString { OpCast.InvokeTwoToString(v1, v2, frame, step.token, scope, frame._tempSlot1, frame._tempSlot2, step, _execAdd_InvokeToString_CallBacker); } }
public static bool create_paraScope_WithSignature_AllParaOnStack(StackFrame frame, ASBinCode.OpStep step, RunTimeScope scope) { rtFunction function = (rtFunction)step.arg1.getValue(frame.scope, frame); var functionDefine = frame.player.swc.functions[function.functionId]; if (frame.baseBottomSlotIndex + frame.call_parameter_slotCount + functionDefine.signature.onStackParameters >= Player.STACKSLOTLENGTH) { frame.throwError(new error.InternalError(frame.player.swc, step.token, "stack overflow")); frame.endStep(); return(false); } var funcCaller = frame.player.funcCallerPool.create(frame, step.token); funcCaller.SetFunction(function); function.Clear(); funcCaller.toCallFunc = functionDefine; frame.funCaller = funcCaller; frame.call_parameter_slotCount += functionDefine.signature.onStackParameters; funcCaller.onstackparametercount = functionDefine.signature.onStackParameters; funcCaller.CallFuncHeap = Player.emptyMembers; var parameters = functionDefine.signature.parameters; int len = parameters.Count; int parast = frame.baseBottomSlotIndex + frame.call_parameter_slotCount; for (int i = step.jumoffset; i < len; i++) { var parameter = parameters[i]; if (parameter.defaultValue != null) { var dv = FunctionCaller.getDefaultParameterValue(parameter.type, parameter.defaultValue.getValue(null, null)); frame.stack[parast - i - 1].directSet(dv); //_storeArgementToSlot(i, dv); } else if (parameter.isPara) { frame.stack[parast - i - 1].directSet(new ASBinCode.rtData.rtArray()); //_storeArgementToSlot(i, new ASBinCode.rtData.rtArray()); } } frame.endStepNoError(); return(true); }
private static void check_para_callbacker(BlockCallBackBase sender,object args) { if (sender.isSuccess) { FunctionCaller caller = (FunctionCaller)sender.cacheObjects[0]; //CallFuncHeap[sender._intArg].directSet(_tempSlot.getValue()); caller.setCheckedParameter(sender._intArg,caller._tempSlot.getValue()); caller.check_para(sender); } else { throw new ASRunTimeException("解释器内部错误,参数类型检查",string.Empty); //invokerFrame.throwCastException(token, ((RunTimeValueBase)sender.args).rtType, toCallFunc.signature.parameters[sender._intArg].type); //return; } }
public void clear() { token = null; _class = null; step = null; callbacker = null; constructorCaller = null; objectResult = null; constructor = null; _function_constructor = null; objectStoreToSlot = null; toNoticeFailed1 = null; toNoticeFailed2 = null; tempSlot.directSet(ASBinCode.rtData.rtUndefined.undefined); }
public static void execNeg(StackFrame frame, ASBinCode.OpStep step, ASBinCode.RunTimeScope scope) { ASBinCode.RunTimeValueBase v = step.arg1.getValue(scope, frame); if (v.rtType != ASBinCode.RunTimeDataType.rt_number) { var f = frame.player.swc.operatorOverrides.getOperatorFunction(OverrideableOperator.Unary_negation, 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 { OpCast.InvokeTwoValueOf(v, ASBinCode.rtData.rtNull.nullptr, frame, step.token, scope, frame._tempSlot1, frame._tempSlot2, step, _execNeg_ValueOf_Callbacker); } } else { step.reg.getSlot(scope, frame).setValue(-((ASBinCode.rtData.rtNumber)v).value);//new ASBinCode.rtData.rtNumber( -((ASBinCode.rtData.rtNumber)v).value)); //frame.endStep(step); frame.endStepNoError(); } }
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); } }
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); } }