private void NewParameterInfo(AbcCode code, AbcInstance instance, IParameter param, int varMethod, int varParam)
{
var pitype = _generator.Corlib.GetType(CorlibTypeId.ParameterInfo);
if (param.Type == null)
{
throw new InvalidOperationException("Parametr type is null");
}
var ctor = pitype.FindConstructor(0);
if (ctor == null)
{
throw new InvalidOperationException(".ctor not found");
}
code.NewObject(ctor, () => { });
code.SetLocal(varParam);
code.GetLocal(varParam);
code.PushInt(GetTypeId(param.Type));
code.SetField(FieldId.ParameterInfo_ClassImpl);
code.GetLocal(varParam);
code.PushString(param.Name);
code.SetField(FieldId.ParameterInfo_NameImpl);
code.GetLocal(varParam);
code.GetLocal(varMethod);
code.SetField(FieldId.ParameterInfo_MemberImpl);
InitCustomAttributes(code, instance, param, varParam);
code.GetLocal(varParam);
}
/// <summary>
/// Create, initialize and put on stack PropertyInfo object
/// </summary>
/// <param name="code"></param>
/// <param name="prop"></param>
private void NewPropertyInfo(AbcCode code, AbcInstance instance, IProperty prop, int varProp)
{
var type = _generator.Corlib.GetType(CorlibTypeId.PropertyInfo);
var ctor = type.FindConstructor(0);
if (ctor == null)
{
throw new InvalidOperationException(".ctor not found");
}
code.NewObject(ctor, () => { });
code.SetLocal(varProp);
code.GetLocal(varProp);
code.PushString(prop.Name);
code.SetField(FieldId.PropertyInfo_Name);
code.GetLocal(varProp);
code.PushTypeId(prop.Type);
code.SetField(FieldId.PropertyInfo_Type);
SetAccessor(code, prop.Getter, FieldId.PropertyInfo_Getter, varProp);
SetAccessor(code, prop.Setter, FieldId.PropertyInfo_Setter, varProp);
InitCustomAttributes(code, instance, prop, varProp);
code.GetLocal(varProp);
}
public void DelayCalls(AbcCode code, IList <AbcInstance> list, int arr)
{
int vf = arr + 1;
code.GetLocal(arr);
int n = list.Count;
for (int i = 0; i < n; ++i)
{
var instance = list[i];
code.PushNativeBool(false); //delayed
code.SetLocal(vf);
GetCalledFlag(code, instance);
var called = code.IfTrue();
SetCalledFlag(code, instance, true);
code.PushNativeBool(true);
code.SetLocal(vf);
called.BranchTarget = code.Label();
code.GetLocal(arr);
code.GetLocal(vf);
code.CallAS3("push", 1);
}
}
public static void set_Item(IMethod method, AbcCode code)
{
code.LoadThis();
code.GetLocal(1);
code.GetLocal(2);
code.SetArrayElem(true);
code.ReturnVoid();
}
public static void CopyTo(IMethod method, AbcCode code)
{
code.LoadThis();
code.GetLocal(1);
code.GetLocal(2);
code.Call(ArrayMethodId.CopyTo);
code.ReturnVoid();
}
private IEnumerable <IInstruction> LoadLocal(int index)
{
var code = new AbcCode(_abc);
code.GetLocal(index);
return(code);
}
private static void TryUnboxNumber(AbcCode code, IType type)
{
const int varValue = 1;
code.GetLocal(varValue);
var ifNotNumber = code.IfType(AvmTypeCode.Number);
code.ThrowInvalidCastException();
ifNotNumber.BranchTarget = code.Label();
code.GetLocal(varValue);
if (!code.TryCastToSystemType(null, type.SystemType()))
{
code.Coerce(type, true);
}
code.ReturnValue();
}
private void InitProperties(AbcCode code, AbcInstance instance, IType type, int varObj)
{
var propertiesInitializer = DefinePropertiesInitializer(instance, type);
code.GetLocal(varObj);
code.GetStaticFunction(propertiesInitializer);
code.SetProperty(Const.Type.PropertiesInit);
}
private void InitCustomAttributes(AbcCode code, AbcInstance instance, ICustomAttributeProvider provider, int var)
{
var init = DefineCustomAttributesInitializer(instance, provider);
code.GetLocal(var);
code.GetStaticFunction(init);
code.SetProperty(Const.MemberInfo.CustomAttrsInit);
}
private void InitMethods(AbcCode code, AbcInstance instance, IType type, int var)
{
var init = DefineMethodsInitializer(instance, type, false);
code.GetLocal(var);
code.GetStaticFunction(init);
code.SetProperty(Const.Type.MethodsInit);
}
public static void get_Item(IMethod method, AbcCode code)
{
var type = method.DeclaringType.GetTypeArgument(0);
code.LoadThis();
code.GetLocal(1);
code.GetArrayElem(type, true);
code.ReturnValue();
}
private static void CreateInstance(AbcCode code, AbcInstance instance, int argLocal)
{
code.CreateInstance(instance,
() =>
{
code.GetLocal(argLocal);
return(1);
});
}
private void InitConstructors(AbcCode code, AbcInstance instance, IType type, int var)
{
// TODO: problem is here
var init = DefineMethodsInitializer(instance, type, true);
code.GetLocal(var);
code.GetStaticFunction(init);
code.SetProperty(Const.Type.ConstructorsInit);
}
/// <summary>
/// Loads value from temporary variable onto the stack
/// </summary>
/// <param name="var"></param>
/// <returns></returns>
public IEnumerable <IInstruction> GetTempVar(int var)
{
if (var >= 0)
{
var code = new AbcCode(_abc);
code.GetLocal(var);
return(code);
}
return(null);
}
public IEnumerable <IInstruction> Rethrow(ISehBlock block)
{
var ci = block.GetCatchInfo();
var code = new AbcCode(_abc);
code.GetLocal(ci.ExceptionVar);
KillExceptionVariable(code, ci);
code.Throw();
return(code);
}
private void InitTypeFuncs(AbcCode code, IType type, AbcInstance instance)
{
var f = _generator.Boxing.Box(type);
if (f != null)
{
code.GetLocal(varType);
code.GetStaticFunction(f);
code.SetProperty(Const.Type.BoxFunction);
}
f = _generator.Boxing.Unbox(type, false);
if (f != null)
{
code.GetLocal(varType);
code.GetStaticFunction(f);
code.SetProperty(Const.Type.UnboxFunction);
}
f = CopyImpl.StaticCopy(instance);
if (f != null)
{
code.GetLocal(varType);
code.GetStaticFunction(f);
code.SetProperty(Const.Type.CopyFunction);
}
var ctor = type.FindParameterlessConstructor();
if (ctor != null)
{
f = _generator.MethodBuilder.Build(ctor) as AbcMethod;
if (f != null && !f.IsInitializer)
{
f = _generator.TypeBuilder.DefineCtorStaticCall(ctor);
Debug.Assert(f != null);
code.GetLocal(varType);
code.GetStaticFunction(f);
code.SetProperty(Const.Type.CreateFunction);
}
}
}
private void NewAttribute(AbcCode code, ICustomAttribute attr, int varAttr)
{
code.NewObject(attr.Constructor,
() =>
{
foreach (var arg in attr.FixedArguments())
{
code.PushValue(code, arg.Value);
}
});
code.SetLocal(varAttr);
//TODO: Set fields and properties
foreach (var arg in attr.NamedArguments())
{
code.GetLocal(varAttr);
code.PushValue(code, arg.Value);
if (arg.Kind == ArgumentKind.Field)
{
var field = arg.Member as IField;
if (field == null)
{
throw new InvalidOperationException();
}
code.SetField(field);
}
else
{
var prop = arg.Member as IProperty;
if (prop == null)
{
throw new InvalidOperationException();
}
var s = _generator.MethodBuilder.BuildAbcMethod(prop.Setter);
code.Call(s);
}
}
code.GetLocal(varAttr);
}
private IEnumerable <IInstruction> EndFinally(ISehHandlerBlock block, bool fault)
{
var handlerInfo = block.GetHandlerInfo();
var ci = handlerInfo.CatchInfo;
var fi = handlerInfo.FinallyInfo;
if (fi.IsFault != fault)
{
throw new InvalidOperationException("Finally block type mistmatch!");
}
var code = new AbcCode(_abc);
if (fault)
{
code.GetLocal(ci.ExceptionVar);
KillExceptionVariable(code, ci);
code.Throw();
}
else
{
// check if we should rethrow exception
code.GetLocal(fi.RethrowFlagVariable);
// trying to fix IVDiffGramTest
// KillTempVar(code, fi.RethrowFlagVariable);
var br = code.IfFalse();
code.GetLocal(ci.ExceptionVar);
KillExceptionVariable(code, ci);
var end = code.Throw();
br.GotoNext(end);
}
return(code);
}
private void NewMethodInfo(AbcCode code, AbcInstance instance, IMethod method,
int varMethod, int varParams, int varParam,
IType mtype, int index)
{
var ctor = mtype.FindConstructor(0);
if (ctor == null)
{
throw new InvalidOperationException(".ctor not found");
}
var abcMethod = method.AbcMethod();
if (abcMethod == null)
{
throw new InvalidOperationException();
}
abcMethod.MethodInfoIndex = index;
code.NewObject(ctor, () => { });
code.SetLocal(varMethod);
code.GetLocal(varMethod);
code.PushString(method.Name);
code.SetField(FieldId.MethodBase_Name);
code.GetLocal(varMethod);
var wrapper = DefineMetodWrapper(method, true);
code.GetStaticFunction(wrapper);
code.SetField(FieldId.MethodBase_Function);
if (method.IsConstructor)
{
code.GetLocal(varMethod);
wrapper = DefineMetodWrapper(method, false);
code.GetStaticFunction(wrapper);
code.SetField(FieldId.ConstructorInfo_CreateFunction);
}
var mattrs = (int)GetMethodAttributes(method);
code.GetLocal(varMethod);
code.PushInt(mattrs);
code.SetField(FieldId.MethodBase_Attributes);
code.GetLocal(varMethod);
code.NewArray(varParams, mtype, method.Parameters,
param => NewParameterInfo(code, instance, param, varMethod, varParam));
code.SetField(FieldId.MethodBase_Parameters);
InitCustomAttributes(code, instance, method, varMethod);
code.GetLocal(varMethod);
}
private static void SetAccessor(AbcCode code, IMethod accessor, FieldId fieldId, int varProp)
{
if (accessor == null)
{
return;
}
var abcMethod = accessor.AbcMethod();
if (abcMethod == null)
{
return;
}
int index = abcMethod.MethodInfoIndex;
code.GetLocal(varProp);
code.PushInt(index);
code.SetField(fieldId);
}
void CallToException(AbcCode code, int var)
{
var avmErrors = Assembly.Corlib().FindType("AvmErrors");
if (avmErrors == null)
{
throw new InvalidOperationException(string.Format("Unable to find AvmErrors. Invalid corlib."));
}
EnsureType(avmErrors);
var fromError = avmErrors.Methods.Find("ExceptionFromError", 1);
var m = DefineAbcMethod(fromError);
code.Getlex(m);
code.GetLocal(var);
code.Call(m);
}
public void UndelayCalls(AbcCode code, IList <AbcInstance> list, int arr)
{
int n = list.Count;
for (int i = 0; i < n; ++i)
{
var instance = list[i];
code.GetLocal(arr);
code.PushInt(i);
code.GetNativeArrayItem();
var br = code.IfFalse();
SetCalledFlag(code, instance, false);
br.BranchTarget = code.Label();
}
}
private void InitFields(AbcCode code, AbcInstance instance, IType type)
{
if (!MustInitFields)
{
return;
}
if (type.IsInterface)
{
return;
}
var init = DefineMyFieldsInitializer(instance, type);
if (init != null)
{
code.GetLocal(varType);
code.GetStaticFunction(init);
code.SetProperty(Const.Type.MyFieldsInit);
}
}
private void NewFieldInfo(AbcCode code, AbcInstance instance, IField field, int varField)
{
var trait = field.Data as AbcTrait;
if (trait == null)
{
code.PushNull();
return;
}
var name = trait.Name;
var fieldInfo = _generator.Corlib.GetInstance(CorlibTypeId.FieldInfo);
code.CreateInstance(fieldInfo);
code.SetLocal(varField);
var ns = name.Namespace;
code.GetLocal(varField);
code.PushNamespace(ns);
code.SetField(FieldId.FieldInfo_Namespace);
code.GetLocal(varField);
code.PushString(field.Name);
code.SetField(FieldId.FieldInfo_Name);
int typeIndex = GetTypeId(field.Type);
code.GetLocal(varField);
code.PushInt(typeIndex);
code.SetField(FieldId.FieldInfo_Type);
typeIndex = GetTypeId(field.DeclaringType);
code.GetLocal(varField);
code.PushInt(typeIndex);
code.SetField(FieldId.FieldInfo_DeclType);
code.GetLocal(varField);
code.PushBool(field.IsStatic);
code.SetField(FieldId.FieldInfo_IsStatic);
if (GlobalSettings.ReflectionSupport)
{
InitCustomAttributes(code, instance, field, varField);
}
code.GetLocal(varField);
}
private void RunTest(AbcCode code, IMethod test)
{
var testFixture = test.DeclaringType;
var testType = GetType(NUnitTypeId.Test);
var testInstance = GetInstance(NUnitTypeId.Test);
const int varTest = 1;
code.CreateInstance(testInstance);
code.SetLocal(varTest);
code.GetLocal(varTest);
code.PushString(test.FullName);
code.SetProperty(testType, "Name");
code.GetLocal(varTest);
code.PushString(testFixture.FullName);
code.SetProperty(testType, "SuiteName");
string desc = test.GetTestDescription();
if (!string.IsNullOrEmpty(desc))
{
code.GetLocal(varTest);
code.PushString(desc);
code.SetProperty(testType, "Description");
}
desc = testFixture.GetTestDescription();
if (!string.IsNullOrEmpty(desc))
{
code.GetLocal(varTest);
code.PushString(desc);
code.SetProperty(testType, "SuiteDescription");
}
var func = DefineTestRunner(test);
code.GetLocal(varTest);
code.GetStaticFunction(func);
//code.CallSetter(testType, "Func");
code.SetField(testType, "Func");
//register test in FlashTestRunner
code.CallStatic(GetMethod(NUnitMethodId.TestRunner_Register), () => code.GetLocal(varTest));
}
private void InitFields(AbcCode code, IType type, IType elemType, int varArray)
{
InitFields(code, type, elemType, () => code.GetLocal(varArray));
}
private AbcMethod BuildCtorImpl(IMethod method, AbcInstance instance)
{
if (!method.IsConstructor)
{
return(null);
}
if (method.IsStatic)
{
return(null);
}
var type = method.DeclaringType;
if (!type.IsArray)
{
return(null);
}
var ctor = new AbcMethod
{
ReturnType = Abc.BuiltinTypes.Void
};
_generator.MethodBuilder.BuildParameters(ctor, method);
string name1 = "arrctor_" + type.GetSigName();
var name = Abc.DefineName(QName.Global(name1));
var trait = AbcTrait.CreateMethod(ctor, name);
instance.Traits.Add(trait);
var body = new AbcMethodBody(ctor);
Abc.AddMethod(ctor);
var code = new AbcCode(Abc);
code.PushThisScope();
code.ConstructSuper();
//check arguments
int n = method.Parameters.Count;
for (int i = 0; i < n; ++i)
{
code.GetLocal(i + 1);
code.PushInt(0);
var br = code.If(BranchOperator.GreaterThanOrEqual);
var exceptionType = _generator.Corlib.GetType(CorlibTypeId.ArgumentOutOfRangeException);
code.ThrowException(exceptionType);
br.BranchTarget = code.Label();
}
//m_rank = n
code.LoadThis();
code.PushInt(n);
code.SetProperty(Const.Array.Rank);
int varSize = n + 1;
for (int i = 0; i < n; ++i)
{
code.GetLocal(i + 1);
}
for (int i = 1; i < n; ++i)
{
code.Add(InstructionCode.Multiply_i);
}
code.SetLocal(varSize);
//init m_value
code.LoadThis();
code.CreateArrayVarSize(varSize);
code.SetProperty(Const.Array.Value);
//init m_lengths
code.LoadThis();
for (int i = 0; i < n; ++i)
{
code.GetLocal(i + 1);
}
code.Add(InstructionCode.Newarray, n);
code.SetProperty(Const.Array.Lengths);
int varDimArr = varSize + 1;
//init m_dims
code.CreateArray(n - 1);
code.SetLocal(varDimArr);
//1, n, n * (n-1), ..., n * (n-1) * ... * n0
for (int i = n - 2; i >= 0; --i)
{
int leni = i + 2;
code.GetLocal(varDimArr);
code.PushInt(i);
if (i != n - 2)
{
code.GetLocal(varDimArr);
code.PushInt(i + 1);
code.GetNativeArrayItem();
code.CoerceInt32(); //prev
code.GetLocal(leni);
code.Add(InstructionCode.Multiply_i); //prev * leni
}
else
{
code.GetLocal(leni);
}
code.SetNativeArrayItem();
}
code.LoadThis();
code.GetLocal(varDimArr);
code.SetProperty(Const.Array.Dims);
var elemType = type.GetElementType();
InitFields(code, type, elemType, 0);
if (InternalTypeExtensions.IsInitArray(elemType))
{
code.InitArray(elemType,
() =>
{
code.LoadThis();
code.GetProperty(Const.Array.Value);
}, varSize);
}
code.ReturnVoid();
body.Finish(code);
return(ctor);
}
private void InitPointers(AbcCode code)
{
if (!HasActivationVar)
{
return;
}
if (AbcGenConfig.UseActivationTraits)
{
code.NewActivation();
if (AbcGenConfig.UseFuncPointers)
{
code.Dup();
code.PushThisScope();
code.PushScope();
}
}
else
{
code.CreateInstance(_activation);
}
code.SetLocal(_activationVar);
if (IsThisAddressed)
{
var ptr = DefineThisPtr();
GetActivation(code);
code.LoadThis();
code.SetSlot(ptr.Slot);
InitSlotPtr(code, ptr);
}
//store arguments in slots
int n = _method.Parameters.Count;
for (int i = 0; i < n; ++i)
{
var p = _method.Parameters[i];
var ptr = p.Data as VarPtr;
if (ptr == null)
{
continue;
}
GetActivation(code);
code.GetLocal(GetArgIndex(i));
code.SetSlot(ptr.Slot);
InitSlotPtr(code, ptr);
}
if (HasLocalVariables)
{
n = VarCount;
for (int i = 0; i < n; ++i)
{
var v = GetVar(i);
var ptr = v.Data as VarPtr;
if (ptr == null)
{
continue;
}
InitSlotPtr(code, ptr);
}
}
//NOTE: Because of VerifyError #1068
if (AbcGenConfig.UseActivationTraits && AbcGenConfig.UseFuncPointers)
{
code.PopScope(); //activation
code.PopScope(); //this
}
}
private void GetActivation(AbcCode code)
{
code.GetLocal(_activationVar);
}
void RouteException(AbcCode code, ISehHandlerBlock block, int var)
{
var exceptionType = block.ExceptionType;
if (block.PrevHandler == null)
{
//if err is AVM error then we translate it to System.Exception.
//code.GetLocal(var);
//code.As(AvmTypeCode.Error);
//code.PushNull();
//var ifNotError = code.IfEquals();
code.GetLocal(var);
code.As(SystemTypes.Exception, true);
code.PushNull();
var ifExc = code.IfNotEquals();
code.GetLocal(var);
code.As(AvmTypeCode.Error);
code.PushNull();
var ifNotError = code.IfEquals();
CallToException(code, var);
code.CoerceAnyType();
code.SetLocal(var);
//check my exception
var labelNotError = code.Label();
ifExc.BranchTarget = labelNotError;
ifNotError.BranchTarget = labelNotError;
}
code.GetLocal(var);
var handlerInfo = (SehHandlerInfo)block.Tag;
handlerInfo.CheckExceptionLabel = code.Label();
//NOTE: Exception on stack can be routed from previous handlers
code.SetLocal(var);
code.GetLocal(var);
code.As(exceptionType, true);
code.PushNull();
var ifMyException = code.IfNotEquals();
//Routing to another exception handler or rethrow
//Instruction routing = Label();
if (block.NextHandler == null)
{
code.GetLocal(var);
code.Throw();
}
else
{
code.GetLocal(var);
handlerInfo.JumpToNextHandler = code.Goto();
}
//Normal Execution: Prepare stack for handler
var normal = code.Label();
ifMyException.BranchTarget = normal;
code.GetLocal(var);
code.Coerce(exceptionType, true);
//21 instructions for first handler
//11 instructions for other handlers
}
