/// <summary>
/// Imports given namespace set.
/// </summary>
/// <param name="nss">namespace set to import.</param>
/// <returns>imported namespace set.</returns>
public override AbcNamespaceSet Import(AbcNamespaceSet nss)
{
if (nss == null)
{
return(null);
}
if (IsDefined(nss))
{
return(nss);
}
string key = nss.Key;
var set = this[key];
if (set != null)
{
return(set);
}
int n = nss.Count;
var namespaces = new AbcNamespace[n];
for (int i = 0; i < n; ++i)
{
namespaces[i] = _abc.ImportConst(nss[i]);
}
set = new AbcNamespaceSet(namespaces, key);
Add(set);
return(set);
}
public AbcScript DefineNamespaceScript(AbcNamespace ns, string name)
{
if (ns == null)
{
throw new ArgumentNullException("ns");
}
var script = _nsscripts[name] as AbcScript;
if (script != null)
{
return(script);
}
ns = ImportConst(ns);
var traitName = DefineName(QName.Global(name));
script = new AbcScript
{
Initializer = DefineEmptyMethod()
};
_nsscripts[name] = script;
script.Traits.AddConst(BuiltinTypes.Namespace, traitName, ns);
return(script);
}
private bool HasNamespace(AbcNamespace ns)
{
if (NamespaceSet == null)
{
return(false);
}
return(((IEnumerable <AbcNamespace>)NamespaceSet).Contains(ns));
}
/// <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);
}
public AbcMultiname DefineMultiname(AbcConstKind kind, AbcNamespace ns, AbcConst <string> name)
{
string key = AbcMultiname.KeyOf(kind, ns, name);
var mn = Multinames[key];
if (mn != null)
{
return(mn);
}
mn = new AbcMultiname(kind, ns, name)
{
Key = key
};
Multinames.Add(mn);
return(mn);
}
private static QName GetName(ITypeMember member)
{
string name;
string ns = "";
var nskind = AbcConstKind.PackageNamespace;
var type = member as IType;
var attr = member.FindAttribute(Attrs.QName);
if (attr == null)
{
if (type != null)
{
ns = type.Namespace;
}
var method = member as IMethod;
if (method != null && (method.IsGetter() || method.IsSetter()))
{
name = member.Name.Substring(4);
}
else
{
name = member.Name;
}
}
else
{
int n = attr.Arguments.Count;
if (n == 0)
{
throw new InvalidOperationException("Invalid qname attribute");
}
name = (string)attr.Arguments[0].Value;
if (n > 1)
{
ns = (string)attr.Arguments[1].Value;
string kind = (string)attr.Arguments[2].Value;
nskind = AbcNamespace.FromShortNsKind(kind);
}
}
return(new QName {
Name = name, Namespace = ns, NamespaceKind = nskind
});
}
private AbcMultiname ImportQName(AbcNamespace ns, AbcConst <string> name, bool isAttribute)
{
var kind = isAttribute ? AbcConstKind.QNameA : AbcConstKind.QName;
string key = AbcMultiname.KeyOf(kind, ns, name);
var mn = this[key];
if (mn != null)
{
return(mn);
}
name = _abc.ImportConst(name);
ns = _abc.ImportConst(ns);
mn = new AbcMultiname(kind, ns, name)
{
Key = key
};
Add(mn);
return(mn);
}
public AbcMultiname(AbcConstKind kind, AbcNamespace ns, AbcConst <string> name)
{
Kind = kind;
Namespace = ns;
Name = name;
}
public static string KeyOf(AbcConstKind kind, AbcNamespace ns, AbcConst <string> name)
{
return(ns.Key + "." + name.Value + (int)kind);
}
/// <summary>
/// Imports <see cref="AbcNamespace"/> constant.
/// </summary>
/// <param name="ns">namespace to import.</param>
/// <returns></returns>
public AbcNamespace ImportConst(AbcNamespace ns)
{
return(Namespaces.Import(ns));
}
/// <summary>
/// Defines qname.
/// </summary>
/// <param name="ns">namespace of qname to define</param>
/// <param name="name">name of qname to define</param>
/// <returns></returns>
public AbcMultiname DefineQName(AbcNamespace ns, string name)
{
var s = DefineString(name);
return(DefineMultiname(AbcConstKind.QName, ns, s));
}