internal bool IsTypeUsed(AbcMultiname typename) { foreach (var t in GetAllTraits()) { switch (t.Kind) { case AbcTraitKind.Function: case AbcTraitKind.Getter: case AbcTraitKind.Setter: case AbcTraitKind.Method: { var m = t.Method; if (m.IsTypeUsed(typename)) { return(true); } } break; case AbcTraitKind.Const: case AbcTraitKind.Slot: { if (ReferenceEquals(t.SlotType, typename)) { return(true); } } break; } } return(false); }
private AbcMultiname ImportType(AbcMultiname name, out AbcInstance type) { type = null; if (name == null) { return(null); } if (IsImportTypeExternally) { return(ImportConst(name)); } if (name.IsRuntime) { return(ImportConst(name)); } type = ImportInstance(name); if (type != null) { name = type.Name; } return(ImportConst(name)); }
public static AbcTrait CreateMethod(AbcMethod method, AbcMultiname name) { var t = CreateMethod(method); t.Name = name; return(t); }
private AbcMultiname ImportType(AbcMultiname name) { AbcInstance type; name = ImportType(name, out type); return(name); }
static void CheckQName(AbcMultiname mn) { if (mn.Kind != AbcConstKind.QName) { Debugger.Break(); } }
public AbcTrait AddConst(AbcMultiname type, AbcMultiname name, object value) { var t = AbcTrait.CreateConst(type, name, value); Add(t); return(t); }
public AbcTrait AddSlot(AbcMultiname type, AbcMultiname name) { var t = AbcTrait.CreateSlot(type, name); Add(t); return(t); }
internal bool IsInheritedFrom(AbcMultiname typename) { if (ReferenceEquals(BaseTypeName, typename)) { return(true); } return(_interfaces.Any(iface => ReferenceEquals(iface, typename))); }
public static AbcTrait CreateSlot(AbcMultiname type, AbcMultiname name) { return(new AbcTrait(AbcTraitKind.Slot) { Name = name, SlotType = type }); }
internal bool IsTypeUsed(AbcMultiname typeName) { if (ReferenceEquals(ReturnType, typeName)) { return(true); } return(Parameters.Any(p => ReferenceEquals(p.Type, typeName))); }
public static AbcTrait CreateConst(AbcMultiname type, AbcMultiname name, object value) { return(new AbcTrait(AbcTraitKind.Const) { Name = name, SlotType = type, SlotValue = value }); }
private static bool ExcludeTypeName(AbcMultiname name) { if (name.IsRuntime) { return(true); } return(false); }
/// <summary> /// Determines whether the given <see cref="AbcMultiname"/> is defined in this ABC file. /// </summary> /// <param name="name">name to check</param> /// <returns></returns> public bool IsDefined(AbcMultiname name) { if (name == null) { return(false); } int index = name.Index; if (index < 0 || index >= Multinames.Count) { return(false); } return(ReferenceEquals(Multinames[index], name)); }
internal AbcInstance ImportInstance(AbcMultiname name) { var assembly = ApplicationAssembly; if (assembly != null) { var instance = AssemblyIndex.FindInstance(assembly, name); if (instance != null) { return(ImportInstance(instance)); } } return(null); }
public AbcMultiname(AbcMultiname type, AbcMultiname param) { if (type == null) { throw new ArgumentNullException("type"); } if (param == null) { throw new ArgumentNullException("param"); } Kind = AbcConstKind.TypeName; Type = type; TypeParameter = param; }
public AbcTrait FindSuperTrait(AbcMultiname name, AbcTraitKind kind) { var st = BaseInstance; while (st != null) { var t = st.Traits.Find(name, kind); if (t != null) { return(t); } st = st.BaseInstance; } return(null); }
public AbcMultiname DefineMultiname(AbcConstKind kind, AbcNamespaceSet nss) { string key = AbcMultiname.KeyOf(kind, nss); var mn = Multinames[key]; if (mn != null) { return(mn); } mn = new AbcMultiname(kind, nss) { Key = key }; Multinames.Add(mn); return(mn); }
private AbcMultiname ToMultiname(AbcMultiname name) { if (name.IsMultiname) { return(name); } if (!name.IsQName) { throw new ArgumentException(string.Format("name {0} is not qname", name)); } var ns = name.Namespace; var nss = DefineNamespaceSet(ns); var kind = name.Kind == AbcConstKind.QName ? AbcConstKind.Multiname : AbcConstKind.MultinameA; return(DefineMultiname(kind, nss, name.Name)); }
internal AbcInstance FindInstance(AbcMultiname name, bool seeExternal) { if (name == null) { return(null); } if (name.IsRuntime) { return(null); } AbcInstance instance; if (seeExternal) { var asm = ApplicationAssembly; if (asm != null) { instance = AssemblyIndex.FindInstance(asm, name); if (instance != null) { return(instance); } } } instance = Instances[name]; if (instance != null) { return(instance); } var pf = PrevFrame; if (pf != null) { Debug.Assert(pf != this); instance = pf.FindInstance(name, false); if (instance != null) { return(instance); } } return(null); }
public AbcInstance Find(AbcMultiname multiname) { if (multiname == null) { throw new ArgumentNullException("multiname"); } if (multiname.IsAny || multiname.IsRuntime) { return(null); } string name = multiname.NameString; if (string.IsNullOrEmpty(name)) { return(null); } return(multiname.GetFullNames() .Select(fullName => Find(fullName)) .FirstOrDefault(x => x != null)); }
public AbcInstance FindStrict(AbcMultiname name) { return(this.FirstOrDefault(i => ReferenceEquals(i.Name, name))); }
public AbcParameter(AbcMultiname type) { Type = type; }
public void Read(SwfReader reader) { Kind = (AbcConstKind)reader.ReadUInt8(); switch (Kind) { //U30 ns_index //U30 name_index case AbcConstKind.QName: case AbcConstKind.QNameA: Namespace = reader.ReadAbcNamespace(); Name = reader.ReadAbcString(); break; //U30 name_index case AbcConstKind.RTQName: case AbcConstKind.RTQNameA: Name = reader.ReadAbcString(); break; case AbcConstKind.RTQNameL: case AbcConstKind.RTQNameLA: //This kind has no associated data. break; //U30 name_index //U30 ns_set_index case AbcConstKind.Multiname: case AbcConstKind.MultinameA: { Name = reader.ReadAbcString(); int index = (int)reader.ReadUIntEncoded(); //ns_set if (index == 0) { throw new BadImageFormatException("The value of ns_set cannot be zero."); } NamespaceSet = reader.ABC.NamespaceSets[index]; } break; //U30 ns_set_index case AbcConstKind.MultinameL: case AbcConstKind.MultinameLA: { int index = (int)reader.ReadUIntEncoded(); //ns_set if (index == 0) { throw new BadImageFormatException("The value of ns_set cannot be zero."); } NamespaceSet = reader.ABC.NamespaceSets[index]; } break; case AbcConstKind.TypeName: { int typeIndex = (int)reader.ReadUIntEncoded(); if (typeIndex == 0 || typeIndex >= reader.MultinameCount) { throw new BadImageFormatException(string.Format("TypeIndex {0} is out of range", typeIndex)); } Type = reader.ABC.Multinames[typeIndex]; int one = (int)reader.ReadUIntEncoded(); if (one != 1) { throw new BadImageFormatException("TypeName constant must have 1 after type"); } //NOTE: In Tamarin AbcParser does not check paramIndex //Therefore param multiname can be not read yet. int paramIndex = (int)reader.ReadUIntEncoded(); TypeParameter = new AbcMultiname { Index = paramIndex }; } break; default: throw new ArgumentOutOfRangeException(); } }
public AbcParameter(AbcMultiname type, AbcConst <string> name) { Type = type; Name = name; }
public AbcMultiname DefineVectorTypeName(AbcMultiname param) { var mn = new AbcMultiname(BuiltinTypes.Vector, param); return(ImportConst(mn)); }
public AbcInstance this[AbcMultiname name] { get { return(Find(name)); } }
public void AddParam(AbcMultiname type, AbcConst <string> name) { Parameters.Add(new AbcParameter(type, name)); }
public static string BuildKey(AbcMultiname name) { var ns = name.Namespace; return(BuildKey(ns.NameString, name.Name.Value, ns.Kind)); }
public bool Contains(AbcMultiname name) { return(Find(name) != null); }
public AbcMultiname ImportConst(AbcMultiname name) { return(Multinames.Import(name)); }