private static void DumpTrait(TextWriter writer, AbcTrait t) { switch (t.Kind) { case AbcTraitKind.Const: case AbcTraitKind.Slot: writer.WriteLine("\tslot {0}: {1}", t.Name.FullName, t.SlotType.FullName); break; case AbcTraitKind.Getter: writer.WriteLine("\tgetter {0}", t.Name.FullName); break; case AbcTraitKind.Setter: writer.WriteLine("\tsetter {0}", t.Name.FullName); break; case AbcTraitKind.Method: case AbcTraitKind.Function: writer.WriteLine("\t{0}", t.Name.FullName); break; case AbcTraitKind.Class: writer.WriteLine("\tclass {0}", t.Name.FullName); break; } }
private Embed ImportEmbedAsset(AbcTrait from) { if (from == null) { return(null); } var embed = from.Embed; if (embed == null) { return(null); } if (embed.Asset == null) { return(null); } if (!IsSwf) { throw Errors.NotSwf.CreateException(); } var sfc = SwfCompiler; var asset = sfc.Assets.Import(embed); return(new Embed(embed) { Asset = asset, Movie = sfc.Swf }); }
public AbcTrait CreateSlot(object type, object name) { var typeName = DefineTypeNameSafe(type); var mn = DefineName(name); return(AbcTrait.CreateSlot(typeName, mn)); }
public AbcTrait DefineSlot(object name, object type, bool isStatic) { if (name == null) { throw new ArgumentNullException("name"); } if (type == null) { throw new ArgumentNullException("type"); } var traitName = Abc.DefineName(name); var traits = isStatic ? Class.Traits : Traits; var trait = traits.Find(traitName, AbcTraitKind.Slot); if (trait != null) { return(trait); } var typeName = Abc.DefineTypeNameSafe(type); trait = AbcTrait.CreateSlot(typeName, traitName); traits.Add(trait); return(trait); }
public void Add(AbcTrait trait) { if (trait == null) { throw new ArgumentNullException("trait"); } string key = KeyOf(trait); _cache.Add(key, trait); }
private void ImportAssets(AbcTrait trait) { ImportEmbedAsset(trait); if (trait.HasMetadata) { foreach (var e in trait.Metadata) { ProcessMetaEntry(trait.Name.ABC, trait, e); } } }
private void ImportEmbedAsset(AbcTrait trait, AbcTrait from) { var newEmbed = ImportEmbedAsset(from); if (newEmbed == null) { return; } var instance = trait.Class.Instance; trait.Embed = newEmbed; trait.AssetInstance = instance; instance.Embed = newEmbed; }
/// <summary> /// Adds trait to instance or class trait collection. /// </summary> /// <param name="trait">trait to add</param> /// <param name="isStatic">true to add to class trais; false - to instance traits</param> public void AddTrait(AbcTrait trait, bool isStatic) { if (trait == null) { throw new ArgumentNullException("trait"); } //Note: traits for static members are contained within ABC file in array of AbcClass if (isStatic) { _class.Traits.Add(trait); } else { _traits.Add(trait); } }
public AbcTrait CreateSlot(object name, object type, bool isStatic) { if (name == null) { throw new ArgumentNullException("name"); } if (type == null) { throw new ArgumentNullException("type"); } var traitName = Abc.DefineName(name); var typeName = Abc.DefineTypeNameSafe(type); var trait = AbcTrait.CreateSlot(typeName, traitName); AddTrait(trait, isStatic); return(trait); }
public bool IsDefined(AbcTrait trait) { var instance = trait.Owner as AbcInstance; if (instance != null) { return(IsDefined(instance)); } var klass = trait.Owner as AbcClass; if (klass != null) { return(IsDefined(klass)); } var script = trait.Owner as AbcScript; if (script != null) { return(IsDefined(script)); } return(false); }
private AbcTrait ImportTrait(AbcTrait from) { var trait = new AbcTrait { Kind = from.Kind, Name = ImportConst(from.Name), Attributes = from.Attributes, Property = from.Property }; switch (from.Kind) { case AbcTraitKind.Slot: case AbcTraitKind.Const: { trait.SlotId = from.SlotId; trait.HasValue = from.HasValue; trait.SlotType = ImportType(from.SlotType); if (from.HasValue) { trait.SlotValue = ImportValue(from.SlotValue); } } break; case AbcTraitKind.Method: case AbcTraitKind.Getter: case AbcTraitKind.Setter: { trait.SlotId = from.SlotId; trait.Method = ImportMethod(from.Method); } break; case AbcTraitKind.Class: { var instance = Instances.Find(from.Name) ?? ImportInstance(from.Class.Instance); trait.Class = instance.Class; //trait.SlotID = trait.SlotID; } break; case AbcTraitKind.Function: { trait.SlotId = from.SlotId; trait.Method = ImportMethod(from.Method); } break; } ImportEmbedAsset(trait, from); if (from.HasMetadata) { var md = from.Metadata; if (md != null) { var abc = from.Name.ABC; foreach (var e in md) { if (ProcessMetaEntry(abc, trait, e)) { continue; } var e2 = ImportMetaEntry(abc, e); if (e2 != null) { trait.HasMetadata = true; trait.Metadata.Add(e2); } } } } return(trait); }
private bool ProcessMetaEntry(AbcFile abc, AbcTrait trait, AbcMetaEntry e) { if (ImportResourceBundle(abc, e)) { return(true); } string name = e.NameString; if (name == MetadataTags.Mixin) { var klass = trait.Class; if (klass != null) { var instance = klass.Instance; instance.IsMixin = true; var sfc = SwfCompiler; if (sfc != null) { sfc.Mixins.RegisterMixinClass(instance); } } return(true); } if (name == MetadataTags.RemoteClass) { var sfc = SwfCompiler; if (sfc != null) { var klass = trait.Class; if (klass != null) { string alias = e["alias"]; sfc.FlexInit.RegisterRemoteClass(alias, klass.Instance); } } return(true); } if (name == MetadataTags.Effect) { var sfc = SwfCompiler; if (sfc != null) { string effectName = e["name"]; string effectEvent = e["event"]; sfc.FlexInit.RegisterEffectTrigger(effectName, effectEvent); } return(true); } if (name == MetadataTags.Style) { //TODO: Can be also used to collect inheriting styles var klass = trait.Class; if (klass != null) { klass.Instance.HasStyles = true; var sfc = SwfCompiler; if (sfc != null) { sfc.Mixins.AddStyleClient(klass.Instance); } } } return(false); }
internal AbcMethod DefineMethod(Sig sig, AbcCoder coder, Action <AbcMethod> complete) { if (sig == null) { throw new ArgumentNullException("sig"); } if (!sig.IsInitilizer && sig.Name == null) { throw new InvalidOperationException(); } var klass = Class; if (klass == null) { throw new InvalidOperationException(string.Format("Class is not defined yet for Instance {0}", FullName)); } AbcMultiname traitName = null; AbcTrait trait; bool isStatic = (sig.Semantics & MethodSemantics.Static) != 0; var traits = isStatic ? klass.Traits : Traits; if (sig.IsInitilizer) { if (Initializer != null) { throw new InvalidOperationException(); } } else { traitName = Abc.DefineName(sig.Name); trait = traits.Find(traitName, sig.Kind); if (trait != null) { return(trait.Method); } } var method = new AbcMethod { Method = sig.Source }; var generator = Abc.Generator; if (sig.Source != null) { generator.SetData(sig.Source, method); } AbcMethodBody body = null; if (sig.IsAbstract) { if (coder != null) { throw new InvalidOperationException(); } } else { body = new AbcMethodBody(method); } Abc.AddMethod(method); if (sig.IsInitilizer) { Initializer = method; } else { //for non initializer method we must define trait and return type method.ReturnType = BuildReturnType(sig.ReturnType, method); trait = AbcTrait.CreateMethod(method, traitName); trait.Kind = sig.Kind; if (!isStatic) { trait.IsVirtual = (sig.Semantics & MethodSemantics.Virtual) != 0; trait.IsOverride = (sig.Semantics & MethodSemantics.Override) != 0; } traits.Add(trait); } if (sig.Args != null) { if (sig.Args.Length == 1 && sig.Args[0] is IMethod) { var m = (IMethod)sig.Args[0]; if (generator == null) { throw new InvalidOperationException(); } generator.MethodBuilder.BuildParameters(method, m); } else { Abc.AddParameters(method.Parameters, sig.Args); } } if (body != null && coder != null) { var code = new AbcCode(Abc); coder(code); body.Finish(code); } if (complete != null) { complete(method); } return(method); }
public void Add(AbcTrait trait) { string key = MemberKey.BuildKey(trait.Name); _cache.Add(key, trait.Method); }
private static string KeyOf(AbcTrait trait) { return(Prefix(trait.Kind) + MemberKey.BuildKey(trait.Name)); }