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));
}
