public static string GetShortNsKind(AbcConstKind kind)
{
switch (kind)
{
case AbcConstKind.PrivateNamespace:
return("private");
case AbcConstKind.PublicNamespace:
return("public");
case AbcConstKind.PackageNamespace:
return("package");
case AbcConstKind.InternalNamespace:
return("internal");
case AbcConstKind.ProtectedNamespace:
return("protected");
case AbcConstKind.ExplicitNamespace:
return("explicit");
case AbcConstKind.StaticProtectedNamespace:
return("static protected");
}
return("");
}
public static T ReadAbcConst <T>(this SwfReader reader, AbcConstKind kind)
{
switch (kind)
{
case AbcConstKind.Int:
return((T)(object)reader.ReadIntEncoded());
case AbcConstKind.UInt:
return((T)(object)reader.ReadUIntEncoded());
case AbcConstKind.Double:
return((T)(object)reader.ReadDouble());
case AbcConstKind.String:
{
string s = string.Empty;
var len = (int)reader.ReadUIntEncoded();
if (len > 0)
{
var data = reader.ReadUInt8(len);
s = Encoding.UTF8.GetString(data);
}
return((T)(object)s);
}
default:
throw new NotImplementedException();
}
}
public AbcMultiname Define(AbcConstKind kind)
{
switch (kind)
{
case AbcConstKind.RTQNameL:
if (RTQNameL != null)
{
return(RTQNameL);
}
break;
case AbcConstKind.RTQNameLA:
if (RTQNameLA != null)
{
return(RTQNameLA);
}
break;
default:
throw new InvalidOperationException();
}
var mn = new AbcMultiname(kind);
Add(mn);
return(mn);
}
/// <summary>
/// Gets visibility of specified constant type.
/// </summary>
public static Visibility Visibility(this AbcConstKind value)
{
switch (value)
{
case AbcConstKind.PrivateNamespace:
return(Common.TypeSystem.Visibility.Private);
case AbcConstKind.PublicNamespace:
return(Common.TypeSystem.Visibility.Public);
case AbcConstKind.PackageNamespace:
return(Common.TypeSystem.Visibility.Public);
case AbcConstKind.InternalNamespace:
return(Common.TypeSystem.Visibility.Internal);
case AbcConstKind.ProtectedNamespace:
return(Common.TypeSystem.Visibility.Protected);
case AbcConstKind.StaticProtectedNamespace:
return(Common.TypeSystem.Visibility.Protected);
default:
return(Common.TypeSystem.Visibility.Private);
}
}
public AbcNamespace this[AbcConst <string> name, AbcConstKind kind]
{
get
{
string key = name.MakeKey(kind);
return(this[key]);
}
}
public void Read(SwfReader reader)
{
_kind = (AbcConstKind)reader.ReadUInt8();
if (!_kind.IsNamespace())
{
throw new BadImageFormatException("Invalid namespace kind");
}
Name = reader.ReadAbcString();
}
public AbcNamespace(AbcConst <string> name, AbcConstKind kind, string key)
{
if (!kind.IsNamespace())
{
throw new ArgumentException("Invalid namespace kind");
}
Name = name;
_kind = kind;
_key = key;
}
static void DefineNamespace_Array(AbcFile abc, AbcConstKind kind)
{
var arr = new[] { "", "aaa", "bbb" };
for (int i = 0; i < arr.Length; ++i)
{
var name = arr[i];
var c1 = abc.DefineNamespace(kind, name);
var c2 = abc.DefineNamespace(kind, name);
Assert.AreSame(c1, c2, "#" + kind + ":" + i);
}
}
/// <summary>
/// Defines namespace with given name.
/// </summary>
/// <param name="kind">kind of namespace to define.</param>
/// <param name="name">name of namespace to define.</param>
/// <returns></returns>
public AbcNamespace DefineNamespace(AbcConstKind kind, AbcConst <string> name)
{
string key = name.MakeKey(kind);
var ns = Namespaces[key];
if (ns != null)
{
return(ns);
}
ns = new AbcNamespace(name, kind, key);
Namespaces.Add(ns);
return(ns);
}
private static string BuildKey(string ns, string name, AbcConstKind nskind)
{
string result = "";
if (!string.IsNullOrEmpty(ns))
{
result += ns;
result += ".";
}
result += name;
result += ":";
result += (int)nskind;
return(result);
}
/// <summary>
/// Determines whether specified constant is namespace.
/// </summary>
public static bool IsNamespace(this AbcConstKind value)
{
switch (value)
{
case AbcConstKind.ExplicitNamespace:
case AbcConstKind.InternalNamespace:
case AbcConstKind.PackageNamespace:
case AbcConstKind.PrivateNamespace:
case AbcConstKind.ProtectedNamespace:
case AbcConstKind.PublicNamespace:
case AbcConstKind.StaticProtectedNamespace:
return(true);
}
return(false);
}
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);
}
/// <summary>
/// Returns constant pool for given kind of constants.
/// </summary>
/// <param name="k">kind of constants.</param>
/// <returns></returns>
public IAbcConstPool GetConstPool(AbcConstKind k)
{
switch (k)
{
case AbcConstKind.String:
return(StringPool);
case AbcConstKind.Int:
return(IntPool);
case AbcConstKind.UInt:
return(UIntPool);
case AbcConstKind.Double:
return(DoublePool);
case AbcConstKind.QName:
case AbcConstKind.Multiname:
case AbcConstKind.QNameA:
case AbcConstKind.MultinameA:
case AbcConstKind.RTQName:
case AbcConstKind.RTQNameA:
case AbcConstKind.RTQNameL:
case AbcConstKind.RTQNameLA:
case AbcConstKind.MultinameL:
case AbcConstKind.MultinameLA:
case AbcConstKind.TypeName:
return(Multinames);
case AbcConstKind.PrivateNamespace:
case AbcConstKind.PublicNamespace:
case AbcConstKind.PackageNamespace:
case AbcConstKind.InternalNamespace:
case AbcConstKind.ProtectedNamespace:
case AbcConstKind.ExplicitNamespace:
case AbcConstKind.StaticProtectedNamespace:
return(Namespaces);
case AbcConstKind.NamespaceSet:
return(NamespaceSets);
default:
return(null);
}
}
public object GetConstant(AbcConstKind kind, int index)
{
switch (kind)
{
case AbcConstKind.Int:
return(IntPool[index]);
case AbcConstKind.UInt:
return(UIntPool[index]);
case AbcConstKind.Double:
return(DoublePool[index]);
case AbcConstKind.String:
return(StringPool[index]);
case AbcConstKind.True:
return(true);
case AbcConstKind.False:
return(false);
case AbcConstKind.Null:
return(null);
case AbcConstKind.Undefined:
return(Undefined);
case AbcConstKind.PublicNamespace:
case AbcConstKind.PackageNamespace:
case AbcConstKind.InternalNamespace:
case AbcConstKind.ProtectedNamespace:
case AbcConstKind.ExplicitNamespace:
case AbcConstKind.StaticProtectedNamespace:
case AbcConstKind.PrivateNamespace:
return(Namespaces[index]);
default:
throw new ArgumentOutOfRangeException();
}
}
public AbcMultiname(AbcConstKind kind, AbcNamespaceSet nss)
{
Kind = kind;
NamespaceSet = nss;
}
public AbcMultiname(AbcConstKind kind, AbcNamespaceSet nss, AbcConst <string> name)
{
Kind = kind;
NamespaceSet = nss;
Name = name;
}
public AbcMultiname(AbcConstKind kind, AbcConst <string> name)
{
Kind = kind;
Name = name;
}
public static string KeyOf(AbcConstKind kind, AbcNamespaceSet nss, AbcConst <string> name)
{
return("{" + nss.Key + "}." + name.Value + (int)kind);
}
public static string KeyOf(AbcConstKind kind, AbcNamespaceSet nss)
{
return(nss.Key + (int)kind);
}
public AbcMultiname(AbcConstKind kind)
{
Kind = kind;
}
public static string KeyOf(AbcConstKind kind, AbcNamespace ns, AbcConst <string> name)
{
return(ns.Key + "." + name.Value + (int)kind);
}
/// <summary>
/// Defines namespace with given name.
/// </summary>
/// <param name="kind"></param>
/// <param name="name"></param>
/// <returns></returns>
public AbcNamespace DefineNamespace(AbcConstKind kind, string name)
{
var c = StringPool.Define(name);
return(DefineNamespace(kind, c));
}
public AbcMultiname DefineMultiname(AbcConstKind kind, AbcNamespaceSet nss, string name)
{
var c = DefineString(name);
return(DefineMultiname(kind, nss, c));
}
public AbcMultiname DefineMultiname(AbcConstKind kind)
{
return(Multinames.Define(kind));
}
public static string MakeKey(this AbcConst <string> name, AbcConstKind kind)
{
return(kind == 0 ? "*" : name.Value + (int)kind);
}
public AbcNamespace(AbcConst <string> name, AbcConstKind kind)
: this(name, kind, name.MakeKey(kind))
{
}
