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