public InterfaceMethodGetter(string name, rtti.Class _class
, int refdefinedinblockid
) : base(name, _class, 0, refdefinedinblockid)
{
//cache = new WeakReference(null);
_cachemethod = new rtFunction(-1, false);
}
public static InterfaceMethodGetter LoadInterfaceMethodGetter(BinaryReader reader, CSWCSerizlizer serizlizer, IDictionary <int, object> serizlized, int key)
{
//protected int indexofMember;
int indexofMember = reader.ReadInt32();
//private readonly string _name;
string _name = reader.ReadString();
//public readonly int refdefinedinblockid;
int refdefinedinblockid = reader.ReadInt32();
//protected int functionid;
int functionid = reader.ReadInt32();
///// <summary>
///// 比如说，私有方法就肯定不是虚方法
///// </summary>
//protected bool isNotReadVirtual = false;
bool isNotReadVirtual = reader.ReadBoolean();
RunTimeDataType datetype = reader.ReadInt32();
InterfaceMethodGetter ig = new InterfaceMethodGetter(_name, null, refdefinedinblockid);
serizlized.Add(key, ig);
//protected readonly ASBinCode.rtti.Class _class;
ASBinCode.rtti.Class _class = serizlizer.DeserializeObject <rtti.Class>(reader, rtti.Class.LoadClass);
ig._class = _class;
ig.functionid = functionid;
ig.indexofMember = indexofMember;
ig.isNotReadVirtual = isNotReadVirtual;
ig.valueType = datetype;
ig.link = (InterfaceMethodGetter)serizlizer.DeserializeObject <ISWCSerializable>(reader, ISWCSerializableLoader.LoadIMember);
return(ig);
}
public ClassPropertyGetter(string name, rtti.Class _class, int indexofMember
)
{
this._class = _class;
this.indexofMember = indexofMember;
this._name = name;
this._tempSlot = new PropertySlot();
this.valueType = RunTimeDataType.unknown;
}
public MethodGetterBase(string name, rtti.Class _class, int indexofMember
, int refdefinedinblockid
)
{
this._class = _class;
this.indexofMember = indexofMember;
this._name = name;
this.refdefinedinblockid = refdefinedinblockid;
this.valueType = RunTimeDataType.rt_function;
}
public static StaticClassDataGetter LoadStaticClassDataGetter(BinaryReader reader, CSWCSerizlizer serizlizer, IDictionary <int, object> serizlized, int key)
{
RunTimeDataType type = reader.ReadInt32();
rtti.Class _class = serizlizer.DeserializeObject <rtti.Class>(reader, rtti.Class.LoadClass);
StaticClassDataGetter sd = new StaticClassDataGetter(_class); serizlized.Add(key, sd);
sd.valueType = type;
return(sd);
}
public static SuperPointer LoadSuperPointer(BinaryReader reader, CSWCSerizlizer serizlizer, IDictionary <int, object> serizlized, int key)
{
RunTimeDataType valuetype = reader.ReadInt32();
rtti.Class superClass = serizlizer.DeserializeObject <rtti.Class>(reader, rtti.Class.LoadClass);
rtti.Class thisClass = serizlizer.DeserializeObject <rtti.Class>(reader, rtti.Class.LoadClass);
SuperPointer sp = new SuperPointer(superClass, thisClass); serizlized.Add(key, sp);
sp.valueType = valuetype;
return(sp);
}
public static ClassPropertyGetter LoadClassPropertyGetter(BinaryReader reader,CSWCSerizlizer serizlizer,IDictionary <int,object> serizlized,int key)
{
int indexofMember = reader.ReadInt32();
string _name = reader.ReadString();
ClassPropertyGetter cpg = new ClassPropertyGetter(_name,null,indexofMember);
serizlized.Add(key,cpg);
rtti.Class _class = serizlizer.DeserializeObject <rtti.Class>(reader,rtti.Class.LoadClass);
cpg._class = _class;
cpg.getter = serizlizer.DeserializeObject <MethodGetterBase>(reader,ISWCSerializableLoader.LoadIMember);
cpg.setter = serizlizer.DeserializeObject <MethodGetterBase>(reader,ISWCSerializableLoader.LoadIMember);
return(cpg);
}
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);
}
//abstract class baseinstancecallbacker : IBlockCallBack
//{
// public object args
// {
// get
// ;
// set
// ;
// }
// public ASBinCode.rtti.Object obj { get; set; }
// public ASBinCode.IRunTimeScope objScope { get; set; }
// public ASBinCode.rtData.rtObject rtObject { get; set; }
// public abstract void call(object args);
//}
//class afterCreateStaticInstance : baseinstancecallbacker
//{
// public override void call(object args)
// {
// object[] a = (object[])args;
// exec_step0(
// (Player)a[0],
// (StackFrame)a[1],
// (ASBinCode.OpStep)a[2],
// (ASBinCode.rtti.Class)a[3],
// (ASBinCode.IRunTimeScope)a[4]
// );
// }
//}
//class afterCreateOutScope : baseinstancecallbacker
//{
// public override void call(object args)
// {
// object[] a = (object[])args;
// exec_step1(
// (Player)a[0],
// (StackFrame)a[1],
// (ASBinCode.OpStep)a[2],
// (ASBinCode.rtti.Class)a[3],
// (ASBinCode.IRunTimeScope)a[4]
// );
// }
//}
//class afterCreateInstanceData : baseinstancecallbacker
//{
// public override void call(object args)
// {
// object[] a = (object[])args;
// exec_step2(
// (Player)a[0],
// (StackFrame)a[1],
// (ASBinCode.OpStep)a[2],
// obj,objScope,
// (ASBinCode.IRunTimeScope)a[4],
// rtObject
// );
// }
//}
//class afterCallConstructor : baseinstancecallbacker
//{
// public override void call(object args)
// {
// object[] a = (object[])args;
// exec_step3(
// (ASBinCode.OpStep)a[0],
// obj,objScope,
// (ASBinCode.IRunTimeScope)a[1],
// (StackFrame)a[2]
// );
// }
//}
public static void init_static(StackFrame frame, ASBinCode.OpStep step, ASBinCode.RunTimeScope scope)
{
var player = frame.player;
int classid = ((ASBinCode.rtData.rtInt)step.arg1.getValue(scope, frame)).value;
ASBinCode.rtti.Class as3class = player.swc.classes[classid];
//init_static_class(player, frame, as3class,step.token, scope);
if (InstanceCreator.init_static_class(as3class, player, step.token))
{
//frame.endStep(step);
frame.endStepNoError();
}
//InstanceCreator ic = new InstanceCreator(player, frame, step.token, as3class);
//if (ic.init_static_class(as3class))
//{
// frame.endStep(step);
//}
}
public StaticClassDataGetter(ASBinCode.rtti.Class _class)
{
this._class = _class;
valueType = _class.getRtType();
}
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 void SetTokenAndClass(SourceToken token,Class _class)
{
this.token = token;
this._class = _class;
}
public CSWC Deserialize(byte[] bin)
{
serizlizedObjects.Clear(); stringpool.Clear(); dictSerizlized.Clear();
CSWC swc = new CSWC(); loadingSwc = swc;
using (System.IO.MemoryStream ms = new System.IO.MemoryStream(bin))
{
using (System.IO.BinaryReader br = new System.IO.BinaryReader(ms, System.Text.Encoding.UTF8))
{
int classcount = br.ReadInt32();
for (int i = 0; i < classcount; i++)
{
swc.classes.Add(DeserializeObject <rtti.Class>(br, rtti.Class.LoadClass));
}
int functioncount = br.ReadInt32();
for (int i = 0; i < functioncount; i++)
{
swc.functions.Add(DeserializeObject <rtti.FunctionDefine>(br, rtti.FunctionDefine.LoadFunctionDefine));
}
int blockcount = br.ReadInt32();
for (int i = 0; i < blockcount; i++)
{
swc.blocks.Add(DeserializeObject <CodeBlock>(br, CodeBlock.Deserialize));
}
swc.primitive_to_class_table.Clear();
int tablecount = br.ReadInt32();
for (int i = 0; i < tablecount; i++)
{
swc.primitive_to_class_table.Add(DeserializeObject <rtti.Class>(br, rtti.Class.LoadClass));
}
int dict_vector_type_count = br.ReadInt32();
for (int i = 0; i < dict_vector_type_count; i++)
{
rtti.Class _class = DeserializeObject <rtti.Class>(br, rtti.Class.LoadClass);
RunTimeDataType t = br.ReadInt32();
swc.dict_Vector_type.Add(_class, t);
}
int _dictlinkcreatorcount = br.ReadInt32();
for (int i = 0; i < _dictlinkcreatorcount; i++)
{
string key = br.ReadString();
rtti.Class _class = DeserializeObject <rtti.Class>(br, rtti.Class.LoadClass);
swc._dictlinkcreatorfunctionname.Add(key, _class);
}
swc.operatorOverrides = DeserializeObject <OperatorFunctions>(br, OperatorFunctions.LoadOperatorFunctions);
/////// <summary>
/////// 链接到系统Object的类型
/////// </summary>
////public Class LinkObjectClass;
//SerializeObject<rtti.Class>(bw, swc.LinkObjectClass);
swc.LinkObjectClass = DeserializeObject <rtti.Class>(br, rtti.Class.LoadClass);
/////// <summary>
/////// Class类型
/////// </summary>
////public Class TypeClass;
//SerializeObject<rtti.Class>(bw, swc.TypeClass);
swc.TypeClass = DeserializeObject <rtti.Class>(br, rtti.Class.LoadClass);
/////// <summary>
/////// Object类
/////// </summary>
////public Class ObjectClass;
//SerializeObject<rtti.Class>(bw, swc.ObjectClass);
swc.ObjectClass = DeserializeObject <rtti.Class>(br, rtti.Class.LoadClass);
/////// <summary>
/////// IEnumerator接口
/////// </summary>
////public Class IEnumeratorInterface;
//SerializeObject<rtti.Class>(bw, swc.IEnumeratorInterface);
swc.IEnumeratorInterface = DeserializeObject <rtti.Class>(br, rtti.Class.LoadClass);
/////// <summary>
/////// IEnumerable接口
/////// </summary>
////public Class IEnumerableInterface;
//SerializeObject<rtti.Class>(bw, swc.IEnumerableInterface);
swc.IEnumerableInterface = DeserializeObject <rtti.Class>(br, rtti.Class.LoadClass);
/////// <summary>
/////// yielditerator类
/////// </summary>
////public Class YieldIteratorClass;
//SerializeObject<rtti.Class>(bw, swc.YieldIteratorClass);
swc.YieldIteratorClass = DeserializeObject <rtti.Class>(br, rtti.Class.LoadClass);
/////// <summary>
/////// Function类
/////// </summary>
////public Class FunctionClass;
//SerializeObject<rtti.Class>(bw, swc.FunctionClass);
swc.FunctionClass = DeserializeObject <rtti.Class>(br, rtti.Class.LoadClass);
/////// <summary>
/////// 异常类
/////// </summary>
////public Class ErrorClass;
//SerializeObject<rtti.Class>(bw, swc.ErrorClass);
swc.ErrorClass = DeserializeObject <rtti.Class>(br, rtti.Class.LoadClass);
/////// <summary>
/////// 字典特殊类
/////// </summary>
////public Class DictionaryClass;
//SerializeObject<rtti.Class>(bw, swc.DictionaryClass);
swc.DictionaryClass = DeserializeObject <rtti.Class>(br, rtti.Class.LoadClass);
/////// <summary>
/////// 正则类
/////// </summary>
////public Class RegExpClass;
//SerializeObject<rtti.Class>(bw, swc.RegExpClass);
swc.RegExpClass = DeserializeObject <rtti.Class>(br, rtti.Class.LoadClass);
swc.MaxMemNumberCount = br.ReadInt32();
swc.MaxMemIntCount = br.ReadInt32();
swc.MaxMemUIntCount = br.ReadInt32();
swc.MaxMemBooleanCount = br.ReadInt32();
}
}
loadingSwc = null;
return(swc);
}
public static void create_paraScope(StackFrame frame, ASBinCode.OpStep step, RunTimeScope scope)
{
RunTimeValueBase rv; rtFunction toclear = null;
if (step.arg1 is MethodGetterBase)
{
rv = ((MethodGetterBase)step.arg1).getMethod(frame.scope); toclear = (rtFunction)rv;
}
else
{
rv = step.arg1.getValue(frame.scope, frame);
}
if (rv.rtType > RunTimeDataType.unknown && ClassMemberFinder.check_isinherits(rv, RunTimeDataType._OBJECT + 2, frame.player.swc))
{
//***说明要调用强制类型转换***
ASBinCode.rtti.Class cls = ((rtObjectBase)rv).value._class;
if (frame.typeconvertoperator != null)
{
frame.endStepNoError();
//frame.endStep(step);
return;
}
else if (frame.typeconvertoperator.targettype.instanceClass == null
||
frame.typeconvertoperator.targettype != cls
)
{
frame.throwError(new error.InternalError(frame.player.swc, step.token, "类型转换函数发现内部错误"
));
frame.endStep(step);
return;
}
}
if (rv.rtType == frame.player.swc.FunctionClass.getRtType())
{
rv = TypeConverter.ObjectImplicit_ToPrimitive((rtObjectBase)rv);
}
if (rv.rtType != RunTimeDataType.rt_function)
{
frame.throwError(step.token, 0, "value is not a function");
frame.endStep(step);
}
else
{
ASBinCode.rtData.rtFunction function = (ASBinCode.rtData.rtFunction)rv;
var funcCaller = frame.player.funcCallerPool.create(frame, step.token);
funcCaller.SetFunction(function); if (toclear != null)
{
toclear.Clear();
}
funcCaller._tempSlot = frame._tempSlot1;
funcCaller.loadDefineFromFunction();
if (!funcCaller.createParaScope())
{
return;
}
frame.funCaller = funcCaller;
frame.endStepNoError();
}
}
public static void clear_thispointer(StackFrame frame, ASBinCode.OpStep step, RunTimeScope scope)
{
RunTimeValueBase rv;
rtFunction toclear = null;
if (step.arg1 is MethodGetterBase)
{
rv = ((ClassMethodGetter)step.arg1).getMethodForClearThis(frame.scope);
toclear = (rtFunction)rv;
}
else
{
rv = step.arg1.getValue(frame.scope, frame);
}
if (rv.rtType > RunTimeDataType.unknown && ClassMemberFinder.check_isinherits(rv, RunTimeDataType._OBJECT + 2, frame.player.swc))
{
//***说明要调用强制类型转换***
ASBinCode.rtti.Class cls = ((rtObjectBase)rv).value._class;
if (cls.explicit_from != null)
{
var member = (MethodGetterBase)cls.explicit_from.bindField;
var func = member.getValue(((rtObjectBase)rv).objScope, null);
step.reg.getSlot(scope, frame).directSet(func);
}
else if (cls.implicit_from != null)
{
var member = (MethodGetterBase)cls.implicit_from.bindField;
var func = member.getValue(((rtObjectBase)rv).objScope, null);
step.reg.getSlot(scope, frame).directSet(func);
}
else
{
frame.typeconvertoperator = new typeConvertOperator();
frame.typeconvertoperator.targettype = cls;
step.reg.getSlot(scope, frame).directSet(rv);
}
if (toclear != null)
{
toclear.Clear();
}
frame.endStepNoError();
//frame.endStep(step);
return;
}
if (rv.rtType != RunTimeDataType.rt_function)
{
frame.throwError(
step.token, 0, "value is not a function");
if (toclear != null)
{
toclear.Clear();
}
frame.endStep(step);
return;
}
else
{
ASBinCode.rtData.rtFunction function = (ASBinCode.rtData.rtFunction)rv;
step.reg.getSlot(scope, frame).directSet(rv);
if (!function.ismethod)
{
int classid = ((ASBinCode.rtData.rtInt)step.arg2.getValue(scope, frame)).value;
RunTimeScope o;
if (frame.player.outpackage_runtimescope.TryGetValue(classid, out o))
{
_do_clear_thispointer(frame.player, (ASBinCode.rtData.rtFunction)step.reg.getValue(scope, frame), frame, o.this_pointer);
}
}
if (toclear != null)
{
toclear.Clear();
}
frame.endStepNoError();
}
}
public override void execute3(RunTimeValueBase thisObj, FunctionDefine functionDefine, SLOT returnSlot,SourceToken token,StackFrame stackframe,out bool success)
{
try
{
System.Type arg0;
{
object _temp;
if (!stackframe.player.linktypemapper.rtValueToLinkObject(
argements[0],
stackframe.player.linktypemapper.getLinkType(argements[0].rtType)
,
bin,true,out _temp
))
{
stackframe.throwCastException(token,argements[0].rtType,
functionDefine.signature.parameters[0].type
);
success = false;
return;
}
arg0 = (System.Type)_temp;
}
object _result_ = AutoGenCodeLib.Testobj.CreateTestObj((System.Type)arg0)
;
ASBinCode.rtti.Class as3class = ((ASBinCode.rtData.rtObjectBase)argements[0]).value._class;
stackframe.player.MakeICrossExtendAdapterEnvironment((ICrossExtendAdapter)_result_,as3class);
stackframe.player.linktypemapper.storeLinkObject_ToSlot(_result_,functionDefine.signature.returnType,returnSlot,bin,stackframe.player);
success = true;
}
catch (ASRunTimeException tlc)
{
success = false;
stackframe.throwAneException(token,tlc.Message);
}
catch (InvalidCastException ic)
{
success = false;
stackframe.throwAneException(token,ic.Message);
}
catch (ArgumentException a)
{
success = false;
stackframe.throwAneException(token,a.Message);
}
catch (IndexOutOfRangeException i)
{
success = false;
stackframe.throwAneException(token,i.Message);
}
catch (NotSupportedException n)
{
success = false;
stackframe.throwAneException(token,n.Message);
}
}
public extendnode(rtti.Class cls)
{
nodecls = cls;
}
public SuperPointer(ASBinCode.rtti.Class superClass, rtti.Class thisClass)
{
this.superClass = superClass;
this.thisClass = thisClass;
valueType = superClass.getRtType();
}
