//returns true if passed object is null public AbcMethod IsNullImpl() { var instance = _generator.Corlib.SystemType.Instance; return(instance.DefineMethod( Sig.@static("IsNull", AvmTypeCode.Boolean, AvmTypeCode.Object, "value"), code => { const int value = 1; code.GetLocal(value); var notNull = code.IfNotNull(); code.PushNativeBool(true); code.ReturnValue(); notNull.BranchTarget = code.Label(); code.Try(); code.GetLocal(value); code.Nullable_HasValue(true); code.Add(InstructionCode.Not); code.ReturnValue(); code.BeginCatch(); code.Pop(); code.PushNativeBool(false); code.ReturnValue(); code.EndCatch(true); })); }
/// <summary> /// Creates cast_to_type method via given AS method /// </summary> /// <param name="type"></param> /// <param name="AS"></param> /// <returns></returns> private AbcMethod Impl(IType type, AbcMethod AS, AbcMultiname name) { var instance = AS.Instance; var typeName = _generator.TypeBuilder.BuildMemberType(type); return(instance.DefineMethod( Sig.@static(name, typeName, AvmTypeCode.Object, "value"), code => { const int value = 1; code.GetLocal(value); code.IfNullReturnNull(1); code.Getlex(instance); code.GetLocal(value); code.Call(AS); code.SetLocal(value); code.GetLocal(value); var notNull = code.IfNotNull(false); code.ThrowInvalidCastException(type); notNull.BranchTarget = code.Label(); code.GetLocal(value); code.ReturnValue(); })); }
public AbcMethod ToStringImpl() { var instance = _generator.TypeBuilder.BuildInstance(SystemTypes.String); return(instance.DefineMethod( Sig.@static("cast_to_me", AvmTypeCode.String, AvmTypeCode.Object, "value"), code => { const int value = 1; code.IfNullReturnNull(value); code.If( () => { code.GetLocal(value); code.Is(AvmTypeCode.String); return code.IfTrue(); }, () => { code.GetLocal(value); code.CoerceString(); code.ReturnValue(); }, () => code.ThrowInvalidCastException() ); })); }
private AbcMethod CreateSystemArraySZ() { return(Instance.DefineMethod( Sig.@static("__create_sz_array__", Instance.Name, AvmTypeCode.Int32, "size"), code => { const int varSize = 1; const int varArray = 2; code.CreateInstance(Instance); code.SetLocal(varArray); code.GetLocal(varArray); code.CreateArrayVarSize(varSize); code.SetProperty(Const.Array.Value); //NOTE: explicitly set rank because we did not call default ctor for System.Array code.GetLocal(varArray); code.PushInt(1); code.SetProperty(Const.Array.Rank); code.GetLocal(varArray); code.ReturnValue(); })); }
private static AbcMethod GetHashCodeDic(AbcGenerator generator) { var instance = generator.RuntimeImpl.Instance; var dicType = generator.Abc.DefineName(QName.Package("flash.utils", "Dictionary")); var dic = instance.DefineStaticSlot("hcdic$", dicType); return(instance.DefineMethod( Sig.@static("get_hashcode_dic", dicType), code => { code.LoadThis(); code.GetProperty(dic); var br = code.IfNotNull(); code.LoadThis(); code.CreateInstance(dicType); code.SetProperty(dic); br.BranchTarget = code.Label(); code.LoadThis(); code.GetProperty(dic); code.ReturnValue(); })); }
private AbcMethod CastToDefaultImpl(IType type, bool cast) { const bool me = true; if (cast) { var AS = CastToDefaultImpl(type, false); return(Impl(type, AS, GetCastMethodName(type, me))); } var instance = _generator.TypeBuilder.BuildInstance(type); var typeName = _generator.TypeBuilder.BuildMemberType(type); var name = GetAsMethodName(type, me); return(instance.DefineMethod( Sig.@static(name, typeName, AvmTypeCode.Object, "value"), code => { const int value = 1; code.BeginAsMethod(); code.Try(); code.GetLocal(value); code.Coerce(typeName); code.ReturnValue(); code.CatchReturnNull(); })); }
public AbcMethod InitImpl(IType elemType) { if (!InternalTypeExtensions.IsInitArray(elemType)) { return(null); } if (elemType.IsEnum) { elemType = elemType.ValueType; } string name = "init_" + elemType.GetSigName(); return(Instance.DefineMethod( Sig.@static(name, AvmTypeCode.Void, AvmTypeCode.Array, "arr", AvmTypeCode.Int32, "size"), code => { var init = InitImpl(); var f = DefineInitObjectMethod(elemType); code.LoadThis(); code.GetLocal(1); code.GetLocal(2); code.Getlex(f.Instance); code.GetProperty(f.TraitName); code.Call(init); code.ReturnVoid(); })); }
private AbcMethod DefineCustomAttributesInitializer(AbcInstance instance, ICustomAttributeProvider provider) { instance = FixInstance(instance); var provname = provider.GetQName(); if (provname == null) { provname = NameDummyCounter.ToString(); ++NameDummyCounter; } var name = _generator.Abc.DefineName(QName.PfxPublic("init_custom_attrs_" + provname)); return(instance.DefineMethod( Sig.@static(name, _generator.Corlib.Array.Instance), code => { const int arr = 1; const int varAttr = 2; code.NewArray(arr, SystemTypes.Object, provider.CustomAttributes, attr => NewAttribute(code, attr, varAttr)); code.ReturnValue(); })); }
/// <summary> /// Defines static method to call this ctor. /// </summary> /// <param name="ctor">this ctor</param> /// <returns></returns> public AbcMethod DefineCtorStaticCall(IMethod ctor) { Debug.Assert(ctor.IsConstructor); Debug.Assert(!ctor.IsStatic); var thisCtor = _generator.MethodBuilder.BuildAbcMethod(ctor); if (thisCtor.IsInitializer) { throw new InvalidOperationException("ctor is initializer"); } var declType = ctor.DeclaringType; var instance = BuildInstance(declType); return(instance.DefineMethod( Sig.@static(thisCtor.TraitName.NameString + "__static", instance.Name, thisCtor), code => { code.PushThisScope(); code.CreateInstance(instance); code.Dup(); code.LoadArguments(ctor); code.Call(thisCtor); code.ReturnValue(); })); }
public AbcMethod Exit() { var instance = _generator.Corlib.Environment.Instance; return(instance.DefineMethod( Sig.@static("exit_impl", AvmTypeCode.Void, AvmTypeCode.Int32, "exitCode"), code => { var isFlash = IsFlashPlayer(); code.Getlex(isFlash); code.Call(isFlash); var ifNotFlash = code.IfFalse(); var ns = Abc.DefinePackage("avmplus"); var mn = Abc.DefineQName(ns, "System"); code.Getlex(mn); mn = Abc.DefineQName(ns, "exit"); code.GetLocal(1); //exitCode code.Call(mn, 1); code.ReturnVoid(); ifNotFlash.BranchTarget = code.Label(); ns = Abc.DefinePackage("flash.System"); mn = Abc.DefineQName(ns, "System"); code.Getlex(mn); mn = Abc.DefineQName(ns, "exit"); code.GetLocal(1); //exitCode code.Add(InstructionCode.Coerce_u); //??? code.Call(mn, 1); code.ReturnVoid(); })); }
private AbcMethod BoxNullable(IType type) { if (!type.IsNullableInstance()) { return(null); } var instance = _generator.TypeBuilder.BuildInstance(type); var arg = type.GetTypeArgument(0); var argInstance = _generator.TypeBuilder.BuildInstance(arg); return(instance.DefineMethod( Sig.@static(BoxName, argInstance.Name, type, "value"), code => { const int value = 1; code.If( //hasValue? () => { code.GetLocal(value); code.Nullable_HasValue(true); return code.IfTrue(); }, () => { code.Box(arg, () => code.GetBoxedValue(value)); code.ReturnValue(); }, () => code.ReturnNull() ); })); }
public AbcMethod FindClass() { var instance = _generator.Corlib.SystemType.Instance; return(instance.DefineMethod( Sig.@static(QName.PfxPackage("FindClass"), AvmTypeCode.Class, AvmTypeCode.Namespace, "ns", AvmTypeCode.String, "name"), code => { const int ns = 1; const int name = 2; code.GetLocal(ns); code.GetLocal(name); code.FindPropertyStrict(code.Abc.RuntimeQName); code.GetLocal(ns); code.GetLocal(name); code.GetRuntimeProperty(); code.CoerceClass(); code.ReturnValue(); })); }
private AbcMethod DefineEnumInfoInitializer(IType type) { var enumInstance = type.AbcInstance(); if (enumInstance == null) { throw new InvalidOperationException(); } var EnumInfo = _generator.Corlib.GetInstance(CorlibTypeId.EnumInfo); var name = _generator.Abc.DefineName(QName.PfxPublic("init_enum_info_" + type.GetSigName())); return(enumInstance.DefineMethod( Sig.@static(name, EnumInfo), code => { const int varEnumInfo = 1; const int varArr = 2; code.CreateInstance(EnumInfo); code.SetLocal(varEnumInfo); if (type.HasAttribute("System.FlagsAttribute")) { code.GetLocal(varEnumInfo); code.PushBool(true); code.SetProperty(Const.EnumInfo.Flags); } var fields = type.GetEnumFields(); var utype = type.ValueType; code.GetLocal(varEnumInfo); code.NewArray(varArr, SystemTypes.Object, fields, f => { var val = f.Value; if (val == null) { throw new InvalidOperationException(); } val = ToIntegralType(utype, val); code.Box(type, () => code.LoadConstant(val)); }); code.SetProperty(Const.EnumInfo.Values); code.GetLocal(varEnumInfo); code.NewArray(varArr, SystemTypes.String, fields, field => code.PushString(field.Name)); code.SetProperty(Const.EnumInfo.Names); code.GetLocal(varEnumInfo); code.ReturnValue(); })); }
private AbcMethod ToNullableImpl(IType type, bool cast) { if (!type.IsNullableInstance()) { return(null); } const bool me = true; if (cast) { var AS = ToNullableImpl(type, false); return(Impl(type, AS, GetCastMethodName(type, me))); } var instance = _generator.TypeBuilder.BuildInstance(type); var name = GetAsMethodName(type, me); var typeName = _generator.TypeBuilder.BuildMemberType(type); return(instance.DefineMethod( Sig.@static(name, typeName, AvmTypeCode.Object, "value"), code => { const int value = 1; code.BeginAsMethod(); code.Try(); code.If( //not me? () => { code.GetLocal(value); code.As(typeName); return code.IfNull(); }, //not me () => { code.NewNullable(type, value); code.ReturnValue(); }, //me () => { code.GetLocal(value); code.Coerce(typeName); code.ReturnValue(); } ); code.CatchReturnNull(); })); }
private AbcMethod UnboxNullable(IType type) { if (!type.IsNullableInstance()) { return(null); } var instance = _generator.TypeBuilder.BuildInstance(type); var name = UnboxName; //Rules for operation (T?)obj //1. null => new T?(); //2. if obj is T? => coerce (T?) //3. try unbox T return(instance.DefineMethod( Sig.@static(name, instance, AvmTypeCode.Object, "value"), code => { const int value = 1; code.If( () => { code.GetLocal(value); return code.IfNullable(); }, () => { code.CreateInstance(instance); code.ReturnValue(); }, () => code.If( () => { code.GetLocal(value); code.As(instance.Name); return code.IfNotNull(); }, () => { code.GetLocal(value); code.Coerce(instance.Name); code.ReturnValue(); }, () => { code.NewNullable(type, value); code.ReturnValue(); }) ); })); }
private AbcMethod UnboxStruct(IType type) { if (type == null) { return(null); } if (type.TypeKind != TypeKind.Struct) { return(null); } var instance = _generator.TypeBuilder.BuildInstance(type); var name = UnboxName; return(instance.DefineMethod( Sig.@static(name, instance, AvmTypeCode.Object, "value"), code => { const int value = 1; code.GetLocal(value); code.ThrowNullReferenceException(); var MyNullable = _generator.TypeBuilder.BuildInstance(_generator.Corlib.MakeNullable(type)); code.If( () => { code.GetLocal(value); code.As(MyNullable.Name); return code.IfNull(); }, () => { code.GetLocal(value); code.Coerce(instance.Name); code.ReturnValue(); }, () => { code.GetBoxedValue(value); code.Coerce(instance.Name); code.ReturnValue(); } ); })); }
private AbcMethod BoxPrimitive(IType type) { if (!type.IsBoxableType()) { return(null); } var instance = _generator.TypeBuilder.BuildInstance(type); return(instance.DefineMethod( Sig.@static(BoxName, instance.Name, type, "value"), code => { code.BoxVariable(instance, 1); code.ReturnValue(); })); }
public AbcMethod ToArrayImpl(IType type, bool cast) { if (type == null) { return(null); } if (!type.IsArray) { return(null); } const bool me = false; if (cast) { var AS = ToArrayImpl(type, false); return(Impl(type, AS, GetCastMethodName(type, me))); } var instance = _generator.Corlib.Array.Instance; var typeName = _generator.TypeBuilder.BuildMemberType(type); var name = GetAsMethodName(type, me); return(instance.DefineMethod( Sig.@static(name, typeName, AvmTypeCode.Object, "value"), code => { const int value = 1; code.BeginAsMethod(); code.Try(); code.GetLocal(value); code.Coerce(typeName); code.PushTypeId(type); code.Call(ArrayMethodId.CastTo); code.ReturnValue(); code.CatchReturnNull(); })); }
public static AbcMethod CalcHashCode(AbcGenerator generator) { var instance = generator.RuntimeImpl.Instance; return(instance.DefineMethod( Sig.@static("get_hash_code", AvmTypeCode.Int32, AvmTypeCode.Object), code => { var getDic = GetHashCodeDic(generator); const int varKey = 1; const int varDic = 2; const int varHC = 3; code.PushInt(0); code.SetLocal(varHC); code.LoadThis(); code.Call(getDic); code.SetLocal(varDic); code.GetLocal(varDic); code.GetLocal(varKey); code.GetNativeArrayItem(); //[] code.CoerceInt32(); code.SetLocal(varHC); code.GetLocal(varHC); code.PushInt(0); var br = code.IfNotEquals(); code.GetLocal(varDic); code.GetLocal(varKey); code.CallStatic(generator.Corlib.GetMethod(ObjectMethodId.NewHashCode)); code.SetLocal(varHC); code.GetLocal(varHC); code.SetNativeArrayItem(); //dic[key] = value br.BranchTarget = code.Label(); code.GetLocal(varHC); code.ReturnValue(); })); }
private AbcMethod BuildCctorCaller(AbcInstance instance) { var type = instance.Type; if (type == null) { return(null); } var ctor = DefineStaticCtor(instance, type); if (ctor == null) { return(null); } if (instance.StaticCtorCaller != null) { return(instance.StaticCtorCaller); } var I = _generator.RuntimeImpl.Instance; instance.StaticCtorCaller = I.DefineMethod( Sig.@static("call_cctor." + instance.FullName, AvmTypeCode.Void), code => { //NOTE: we must init class before setting cctor flag to true code.Getlex(ctor); GetCalledFlag(code, instance); var br = code.IfFalse(); code.ReturnVoid(); br.BranchTarget = code.Label(); SetCalledFlag(code, instance, true); code.Call(ctor); code.ReturnVoid(); }); return(instance.StaticCtorCaller); }
public static AbcMethod StaticCopy(AbcInstance instance) { var copy = Copy(instance); if (copy == null) { return(null); } var name = instance.Abc.DefineName(QName.PfxPublic("__static_copy__")); return(instance.DefineMethod( Sig.@static(name, instance.Name, instance.Name, "value"), code => { code.GetLocal(1); //value code.Call(copy); code.ReturnValue(); })); }
private AbcMethod DefineStaticCtor(AbcInstance instance, IType type) { if (type == null) { return(null); } if (instance.IsForeign) { return(null); } if (instance.StaticCtor != null) { return(instance.StaticCtor); } var ctor = type.GetStaticCtor(); if (ctor != null) { return(instance.StaticCtor = _generator.MethodBuilder.BuildAbcMethod(ctor)); } if (type.HasInitFields(true)) { string name = type.GetStaticCtorName(); instance.StaticCtor = instance.DefineMethod( Sig.@static(name, AvmTypeCode.Void), code => { code.PushThisScope(); code.InitFields(type, true, false); code.ReturnVoid(); }); return(instance.StaticCtor); } return(null); }
private AbcMethod DefineInitObjectMethod(IType type) { var instance = _generator.TypeBuilder.BuildInstance(type); AbcMultiname name; if (instance.IsNative) { instance = _generator.Corlib.Object.Instance; name = _generator.Abc.DefineName(QName.PfxPublic("initobj_" + type.GetSigName())); } else { name = _generator.Abc.DefineName(QName.PfxPublic("initobj")); } return(instance.DefineMethod( Sig.@static(name, AvmTypeCode.Object), code => { code.InitObject(type); code.ReturnValue(); })); }
private AbcMethod DefineMethodsInitializer(AbcInstance instance, IType type, bool ctor) { var provname = type.GetSigName(); string prefix = "init_methods_"; if (ctor) { prefix = "init_ctors_"; } var name = _generator.Abc.DefineName(QName.PfxPublic(prefix + provname)); var methods = new List <IMethod>(type.Methods.Where(m => m.IsConstructor == ctor && !IsUnsupportedMethod(m))); var mtype = ctor ? _generator.Corlib.GetType(CorlibTypeId.ConstructorInfo) : _generator.Corlib.GetType(CorlibTypeId.MethodInfo); instance = FixInstance(instance); return(instance.DefineMethod( Sig.@static(name, _generator.Corlib.Array.Instance), code => { const int arr = 1; const int varObj = 2; const int varParams = 3; const int varParam = 4; code.NewArray(arr, mtype, methods, (method, index) => NewMethodInfo(code, instance, method, varObj, varParams, varParam, mtype, index)); code.ReturnValue(); })); }
private AbcMethod InitImpl() { return(Instance.DefineMethod( Sig.@static("init_core", AvmTypeCode.Void, AvmTypeCode.Array, "arr", AvmTypeCode.Int32, "size", AvmTypeCode.Function, "f"), code => { const int arr = 1; const int size = 2; const int func = 3; code.While( () => { code.GetLocal(size); code.Add(InstructionCode.Decrement_i); code.SetLocal(size); code.GetLocal(size); code.Add(InstructionCode.Pushbyte, 0); return code.If(BranchOperator.LessThan); }, () => { code.GetLocal(arr); code.GetLocal(size); code.GetLocal(func); code.PushNull(); code.CallClosure(0); code.SetNativeArrayItem(); } ); code.ReturnVoid(); })); }
private AbcMethod DefineMyFieldsInitializer(AbcInstance instance, IType type) { var myfields = new List <IField>(type.Fields.Where(f => !f.IsStatic)); if (myfields.Count == 0) { return(null); } instance = FixInstance(instance); var name = _generator.Abc.DefineName(QName.PfxPublic("init_myfields_" + GetMethodSuffix(type))); return(instance.DefineMethod( Sig.@static(name, _generator.Corlib.Array.Instance), code => { var typeFieldInfo = _generator.Corlib.GetType(CorlibTypeId.FieldInfo); const int arr = 1; code.NewArray(arr, typeFieldInfo, myfields, f => NewFieldInfo(code, instance, f, 2)); code.ReturnValue(); })); }
/// <summary> /// m_properties initializer /// </summary> /// <param name="type"></param> /// <returns></returns> private AbcMethod DefinePropertiesInitializer(AbcInstance instance, IType type) { var provname = type.GetSigName(); if (provname == null) { provname = NameDummyCounter.ToString(); ++NameDummyCounter; } var name = _generator.Abc.DefineName(QName.PfxPublic("init_properties_" + provname)); instance = FixInstance(instance); return(instance.DefineMethod( Sig.@static(name, _generator.Corlib.Array.Instance), code => { var mtype = _generator.Corlib.GetType(CorlibTypeId.PropertyInfo); const int arr = 1; code.NewArray(arr, mtype, type.Properties, property => NewPropertyInfo(code, instance, property, 2)); code.ReturnValue(); })); }
/// <summary> /// Creates single-dimensional array with given element type. /// </summary> /// <param name="elemType"></param> /// <returns></returns> public AbcMethod NewArray(IType elemType) { _generator.TypeBuilder.Build(elemType); string name1 = "newarr_" + elemType.GetSigName(); var name = Abc.DefineName(QName.Global(name1)); return(Instance.DefineMethod( Sig.@static(name, Instance.Name, AvmTypeCode.Int32, "size"), code => { const int varSize = 1; //size argument const int varArray = 2; var m = CreateSystemArraySZ(); code.LoadThis(); code.GetLocal(varSize); code.Call(m); code.SetLocal(varArray); InitFields(code, elemType, varArray); if (InternalTypeExtensions.IsInitArray(elemType)) { code.InitArray(elemType, () => { code.GetLocal(varArray); code.GetProperty(Const.Array.Value); }, varSize); } code.GetLocal(varArray); code.ReturnValue(); })); }
private AbcMethod DefineTestRunner(IMethod test) { var method = _generator.MethodBuilder.BuildAbcMethod(test); var instance = method.Instance; string name = "run_test_" + test.GetMonoTestCaseName(); name = name.Replace('.', '_'); return(instance.DefineMethod( Sig.@static(name, AvmTypeCode.Void, GetInstance(NUnitTypeId.Test)), code => { var testFixture = test.DeclaringType; const int varTF = 2; const int varErr = 3; //TODO: Redirect Console, Debug output var ee = test.GetExpectedExceptionType(); var setup = testFixture.GetUnitTestSetup(); AbcMethod setupAM = null; if (setup != null) { setupAM = _generator.MethodBuilder.BuildAbcMethod(setup); } Test_Success(code, true); Test_Executed(code, true); code.ConsoleOpenSW(); code.Try(); #region setup & call if (test.IsStatic) { if (setup != null && setup.IsStatic) { code.Getlex(setupAM); code.Call(setupAM); } code.Getlex(method); code.Call(method); } else { code.CreateInstance(testFixture, true); code.CoerceAnyType(); code.SetLocal(varTF); if (setup != null) { code.GetLocal(varTF); code.Call(setupAM); } code.GetLocal(varTF); code.Call(method); } #endregion if (ee != null) { code.ConsoleCloseSW(true); Test_Success(code, false); Test_Output(code, "No expected exception: {0}", ee.FullName); } else { Test_Output(code, () => code.ConsoleCloseSW(false)); } code.ReturnVoid(); if (ee != null) { code.BeginCatch(_generator.TypeBuilder.BuildInstance(ee), false); code.Pop(); Test_Success(code, true); Test_Output(code, () => code.ConsoleCloseSW(false)); code.ReturnVoid(); code.EndCatch(false); } code.BeginCatch(); code.CoerceAnyType(); code.SetLocal(varErr); code.ConsoleCloseSW(true); Test_Success(code, false); Test_Output( code, () => { code.PushString("Unexpected exception: "); code.GetLocal(varErr); code.GetErrorMessage(); code.Add(InstructionCode.Add); }); Test_StackTrace( code, () => { code.GetLocal(varErr); code.GetErrorStackTrace(); }); code.EndCatch(true); code.ReturnVoid(); })); }
internal AbcInstance DefineFlexInitMixin(AbcFile app) { var flexModuleFactoryInterface = FlexTypes.GetFlexModuleFactoryInterface(app); var childManagerInstance = FlexTypes.GetChildManagerInstance(app); var flex4 = childManagerInstance != null; string name = "_FlexInit_" + _compiler.FlexAppPrefix; string ns = _compiler.RootNamespace; var instance = new AbcInstance(true) { Name = app.DefineName(QName.Package(ns, name)), BaseTypeName = app.BuiltinTypes.Object, IsMixin = true, IsFlexInitMixin = true, Initializer = app.DefineMethod( Sig.@this(null, AvmTypeCode.Void), code => { code.ConstructSuper(); code.ReturnVoid(); }), Class = { Initializer = app.DefineEmptyMethod() } }; app.AddInstance(instance); instance.DefineMethod( Sig.@static("init", AvmTypeCode.Void, flexModuleFactoryInterface, "f"), code => { code.PushThisScope(); const int moduleFactoryArg = 1; const int styleManagerVar = 2; if (flex4) { CreateInstance(code, childManagerInstance, moduleFactoryArg); code.Pop(); var styleManager2 = FlexTypes.GetStyleManager2Interface(app); var styleManagerImpl = FlexTypes.GetStyleManagerImpl(app); CreateInstance(code, styleManagerImpl, moduleFactoryArg); code.Coerce(styleManager2); code.SetLocal(styleManagerVar); } RegisterEffectTriggers(app, code); RegisterRemoteClasses(app, code); Action pushStyleManager; if (flex4) { pushStyleManager = () => code.GetLocal(styleManagerVar); } else { pushStyleManager = () => code.Getlex(FlexTypes.GetStyleManagerInstance(app)); } RegisterInheritStyles(app, code, pushStyleManager, flex4); //NOTE: Uncomment to add forward refernce to Flex Application //var appInstance = app.generator.MainInstance; //code.Trace(string.Format("PFC: forward reference to FlexApp class {0}", appInstance.FullName)); //code.Getlex(appInstance); //code.Pop(); code.ReturnVoid(); }); return(instance); }