public ISymbolNamespace GetNamespace()
{
ISymUnmanagedNamespace retVal = null;
m_unmanagedMethod.GetNamespace(out retVal);
return(new SymNamespace(retVal));
}
internal SymbolNamespace(ISymUnmanagedNamespace unmanagedNamespace)
{
if (unmanagedNamespace == null)
{
throw new ArgumentNullException("unmanagedNamespace");
}
this.unmanagedNamespace = unmanagedNamespace;
}
internal SymbolNamespace(ISymUnmanagedNamespace unmanagedNamespace)
{
if (unmanagedNamespace == null)
{
throw new ArgumentNullException("unmanagedNamespace");
}
this.unmanagedNamespace = unmanagedNamespace;
}
internal SymNamespace(ISymUnmanagedNamespace nameSpace)
{
// We should not wrap null instances
if (nameSpace == null)
throw new ArgumentNullException("nameSpace");
m_unmanagedNamespace = nameSpace;
}
// ISymUnmanagedReader
public static ISymUnmanagedNamespace[] GetNamespaces(this ISymUnmanagedReader symReader)
{
uint count;
symReader.GetNamespaces(0, out count, new ISymUnmanagedNamespace[0]);
ISymUnmanagedNamespace[] namespaces = new ISymUnmanagedNamespace[count];
symReader.GetNamespaces(count, out count, namespaces);
return(namespaces);
}
public static ISymUnmanagedNamespace[] GetNamespaces(this ISymUnmanagedScope symScope)
{
uint count;
symScope.GetNamespaces(0, out count, new ISymUnmanagedNamespace[0]);
ISymUnmanagedNamespace[] namespaces = new ISymUnmanagedNamespace[count];
symScope.GetNamespaces(count, out count, namespaces);
return(namespaces);
}
public SymbolNamespace(ISymUnmanagedNamespace unmanaged)
{
if (unmanaged == null)
{
throw new ArgumentNullException("unmanaged");
}
_unmanaged = unmanaged;
}
internal SymNamespace(ISymUnmanagedNamespace nameSpace)
{
// We should not wrap null instances
if (nameSpace == null)
{
throw new ArgumentNullException(nameof(nameSpace));
}
m_unmanagedNamespace = nameSpace;
}
public ISymbolNamespace[] GetNamespaces() {
uint numNss;
scope.GetNamespaces(0, out numNss, null);
var unNss = new ISymUnmanagedNamespace[numNss];
scope.GetNamespaces((uint)unNss.Length, out numNss, unNss);
var nss = new ISymbolNamespace[numNss];
for (uint i = 0; i < numNss; i++)
nss[i] = new SymbolNamespace(unNss[i]);
return nss;
}
public static string GetName(this ISymUnmanagedNamespace @namespace)
{
if (@namespace == null)
{
throw new ArgumentNullException(nameof(@namespace));
}
return(BufferToString(GetItems(@namespace,
(ISymUnmanagedNamespace a, int b, out int c, char[] d) => a.GetName(b, out c, d))));
}
public ISymbolNamespace[] GetNamespaces()
{
uint numNss;
reader.GetNamespaces(0, out numNss, null);
var unNss = new ISymUnmanagedNamespace[numNss];
reader.GetNamespaces((uint)unNss.Length, out numNss, unNss);
var nss = new ISymbolNamespace[numNss];
for (uint i = 0; i < numNss; i++)
nss[i] = new SymbolNamespace(unNss[i]);
return nss;
}
/// <summary>
/// Gets the namespaces that are used within the current scope
/// </summary>
/// <returns>The namespaces that are used within the current scope</returns>
public ISymbolNamespace[] GetNamespaces()
{
int nmNum;
private_scope.GetNamespaces(0, out nmNum, null);
ISymUnmanagedNamespace[] unNams = new ISymUnmanagedNamespace[nmNum];
ISymbolNamespace[] manNams = new ISymbolNamespace[nmNum];
private_scope.GetNamespaces(nmNum, out nmNum, unNams);
for (int i = 0; i < nmNum; i++)
{
manNams[i] = new SymbolNamespace(unNams[i]);
}
return(manNams);
}
public ISymbolNamespace[] GetNamespaces()
{
uint i;
int cNamespaces = 0;
m_unmanagedNamespace.GetNamespaces(0, out cNamespaces, null);
var unmamagedNamespaces = new ISymUnmanagedNamespace[cNamespaces];
m_unmanagedNamespace.GetNamespaces(cNamespaces, out cNamespaces, unmamagedNamespaces);
var Namespaces = new ISymbolNamespace[cNamespaces];
for (i = 0; i < cNamespaces; i++)
{
Namespaces[i] = new SymNamespace(unmamagedNamespaces[i]);
}
return Namespaces;
}
public ISymbolNamespace[] GetNamespaces()
{
m_target.GetNamespaces(0, out var count, null);
ISymUnmanagedNamespace[] uNamespaces = new ISymUnmanagedNamespace[count];
m_target.GetNamespaces(count, out count, uNamespaces);
int i;
ISymbolNamespace[] namespaces = new ISymbolNamespace[count];
for (i = 0; i < count; i++)
{
namespaces[i] = new SymNamespace(uNamespaces[i]);
}
return(namespaces);
}
public ISymbolNamespace[] GetNamespaces()
{
uint i;
int cNamespaces = 0;
m_unmanagedNamespace.GetNamespaces(0, out cNamespaces, null);
ISymUnmanagedNamespace[] unmamagedNamespaces = new ISymUnmanagedNamespace[cNamespaces];
m_unmanagedNamespace.GetNamespaces(cNamespaces, out cNamespaces, unmamagedNamespaces);
ISymbolNamespace[] Namespaces = new ISymbolNamespace[cNamespaces];
for (i = 0; i < cNamespaces; i++)
{
Namespaces[i] = new SymNamespace(unmamagedNamespaces[i]);
}
return(Namespaces);
}
public ISymbolNamespace[] GetNamespaces()
{
int count = 0;
uint i;
m_reader.GetNamespaces(0, out count, null);
ISymUnmanagedNamespace[] unmanagedNamespaces = new ISymUnmanagedNamespace[count];
m_reader.GetNamespaces(count, out count, unmanagedNamespaces);
ISymbolNamespace[] namespaces = new SymNamespace[count];
for (i = 0; i < count; i++)
{
namespaces[i] = new SymNamespace(unmanagedNamespaces[i]);
}
return(namespaces);
}
public ISymbolNamespace[] GetNamespaces()
{
int size;
HRESULT.ThrowOnFailure(_unmanaged.GetNamespaces(0, out size, null));
var unmanagedNamespaces = new ISymUnmanagedNamespace[size];
HRESULT.ThrowOnFailure(_unmanaged.GetNamespaces(unmanagedNamespaces.Length, out size, unmanagedNamespaces));
var namespaces = new ISymbolNamespace[size];
for (int i = 0; i < size; i++)
{
namespaces[i] = new SymbolNamespace(unmanagedNamespaces[i]);
}
return(namespaces);
}
public ISymbolNamespace[] GetNamespaces()
{
int namespaceCount;
HRESULT.ThrowOnFailure(_unmanaged.GetGlobalVariables(0, out namespaceCount, null));
var unmanagedNamespaces = new ISymUnmanagedNamespace[namespaceCount];
HRESULT.ThrowOnFailure(_unmanaged.GetNamespaces(unmanagedNamespaces.Length, out namespaceCount, unmanagedNamespaces));
var namespaces = new ISymbolNamespace[namespaceCount];
for (int i = 0; i < namespaceCount; i++)
{
namespaces[i] = new SymbolNamespace(unmanagedNamespaces[i]);
}
return(namespaces);
}
public static ImmutableArray <ISymUnmanagedNamespace> GetNamespaces(this ISymUnmanagedScope scope)
{
int numNamespacesAvailable;
scope.GetNamespaces(0, out numNamespacesAvailable, null);
if (numNamespacesAvailable == 0)
{
return(ImmutableArray <ISymUnmanagedNamespace> .Empty);
}
int numNamespacesRead;
ISymUnmanagedNamespace[] namespaces = new ISymUnmanagedNamespace[numNamespacesAvailable];
scope.GetNamespaces(numNamespacesAvailable, out numNamespacesRead, namespaces);
if (numNamespacesRead != numNamespacesAvailable)
{
throw new InvalidOperationException(string.Format("Read only {0} of {1} namespaces.", numNamespacesRead, numNamespacesAvailable));
}
return(ImmutableArray.Create(namespaces));
}
public static string GetName(this ISymUnmanagedNamespace @namespace)
{
int numAvailable;
@namespace.GetName(0, out numAvailable, null);
if (numAvailable == 0)
{
return("");
}
var chars = new char[numAvailable];
int numRead;
@namespace.GetName(numAvailable, out numRead, chars);
if (numRead != numAvailable)
{
throw new InvalidOperationException(string.Format("Read only {0} of {1} name characters.", numRead, numAvailable));
}
Debug.Assert(chars[numAvailable - 1] == 0);
return(new string(chars, 0, numAvailable - 1));
}
public static void GetNamespaces(this ISymUnmanagedNamespace instance, uint cNameSpaces, out uint pcNameSpaces, IntPtr namespaces)
{
instance.__GetNamespaces(cNameSpaces, out pcNameSpaces, namespaces);
}
public static void GetName(this ISymUnmanagedNamespace instance, uint cchName, out uint pcchName, IntPtr szName)
{
instance.__GetName(cchName, out pcchName, szName);
}
public int GetNamespace(out ISymUnmanagedNamespace retVal)
{
throw new NotImplementedException();
}
internal SymbolNamespace(ISymUnmanagedNamespace unNmsp)
{
private_namespace = unNmsp;
}
// ISymUnmanagedReader
public static ISymUnmanagedNamespace[] GetNamespaces(this ISymUnmanagedReader symReader)
{
uint count;
symReader.GetNamespaces(0, out count, new ISymUnmanagedNamespace[0]);
ISymUnmanagedNamespace[] namespaces = new ISymUnmanagedNamespace[count];
symReader.GetNamespaces(count, out count, namespaces);
return namespaces;
}
public ISymbolNamespace[] GetNamespaces()
{
int count;
m_target.GetNamespaces(0, out count, null);
ISymUnmanagedNamespace[] uNamespaces = new ISymUnmanagedNamespace[count];
m_target.GetNamespaces(count, out count, uNamespaces);
int i;
ISymbolNamespace[] namespaces = new ISymbolNamespace[count];
for (i = 0; i < count; i++)
{
namespaces[i] = new SymNamespace(uNamespaces[i]);
}
return namespaces;
}
public static void GetNamespaces(this ISymUnmanagedReader instance, uint cNameSpaces, out uint pcNameSpaces, ISymUnmanagedNamespace[] namespaces)
{
instance.__GetNamespaces(cNameSpaces, out pcNameSpaces, namespaces);
}
public SymbolNamespace(ISymUnmanagedNamespace @namespace) {
this.ns = @namespace;
}
internal SymNamespace(ISymUnmanagedNamespace nameSpace)
{
m_unmanagedNamespace = nameSpace;
}
public int GetNamespaces(int cNameSpaces, out int pcNameSpaces, ISymUnmanagedNamespace[] namespaces)
{
return _scope.GetNamespaces(cNameSpaces, out pcNameSpaces, namespaces);
}
public static void GetNamespaces(this ISymUnmanagedScope instance, uint cNameSpaces, out uint pcNameSpaces, ISymUnmanagedNamespace[] namespaces)
{
instance.__GetNamespaces(cNameSpaces, out pcNameSpaces, namespaces);
ProcessOutParameter(namespaces);
}
public static void GetNamespaces(this CorSymReader_SxSClass instance, uint cNameSpaces, out uint pcNameSpaces, ISymUnmanagedNamespace[] namespaces)
{
instance.__GetNamespaces(cNameSpaces, out pcNameSpaces, namespaces);
ProcessOutParameter(namespaces);
}
public SymbolNamespace(ISymUnmanagedNamespace @namespace)
{
this.ns = @namespace;
}
public static void GetVariables(this ISymUnmanagedNamespace instance, uint cVars, out uint pcVars, IntPtr pVars)
{
instance.__GetVariables(cVars, out pcVars, pVars);
}
public int GetNamespace([MarshalAs(UnmanagedType.Interface)] out ISymUnmanagedNamespace @namespace)
{
// SymReader doesn't support namespaces
@namespace = null;
return(HResult.E_NOTIMPL);
}
int ISymUnmanagedMethod.GetNamespace(out ISymUnmanagedNamespace retVal)
{
throw new NotImplementedException();
}
public static string GetName(this ISymUnmanagedNamespace @namespace)
{
return(ToString(GetItems(@namespace,
(ISymUnmanagedNamespace a, int b, out int c, char[] d) => a.GetName(b, out c, d))));
}
// ISymUnmanagedNamespace
public static string GetName(this ISymUnmanagedNamespace symNs)
{
return(Util.GetCorSymString(symNs.GetName));
}
public static ISymUnmanagedNamespace[] GetNamespaces(this ISymUnmanagedScope symScope)
{
uint count;
symScope.GetNamespaces(0, out count, new ISymUnmanagedNamespace[0]);
ISymUnmanagedNamespace[] namespaces = new ISymUnmanagedNamespace[count];
symScope.GetNamespaces(count, out count, namespaces);
return namespaces;
}
private void WriteNamespace(ISymUnmanagedNamespace @namespace)
{
string rawName = @namespace.GetName();
string alias;
string externAlias;
string target;
ImportTargetKind kind;
ImportScope scope;
try
{
if (rawName.Length == 0)
{
externAlias = null;
var parsingSucceeded = CDI.TryParseVisualBasicImportString(rawName, out alias, out target, out kind, out scope);
Debug.Assert(parsingSucceeded);
}
else
{
switch (rawName[0])
{
case 'U':
case 'A':
case 'X':
case 'Z':
case 'E':
scope = ImportScope.Unspecified;
if (!CDI.TryParseCSharpImportString(rawName, out alias, out externAlias, out target, out kind))
{
throw new InvalidOperationException(string.Format("Invalid import '{0}'", rawName));
}
break;
default:
externAlias = null;
if (!CDI.TryParseVisualBasicImportString(rawName, out alias, out target, out kind, out scope))
{
throw new InvalidOperationException(string.Format("Invalid import '{0}'", rawName));
}
break;
}
}
}
catch (ArgumentException) // TODO: filter
{
if ((options & PdbToXmlOptions.ThrowOnError) != 0)
{
throw;
}
writer.WriteStartElement("invalid-custom-data");
writer.WriteAttributeString("raw", rawName);
writer.WriteEndElement();
return;
}
switch (kind)
{
case ImportTargetKind.CurrentNamespace:
Debug.Assert(alias == null);
Debug.Assert(externAlias == null);
Debug.Assert(scope == ImportScope.Unspecified);
writer.WriteStartElement("currentnamespace");
writer.WriteAttributeString("name", target);
writer.WriteEndElement(); // </currentnamespace>
break;
case ImportTargetKind.DefaultNamespace:
Debug.Assert(alias == null);
Debug.Assert(externAlias == null);
Debug.Assert(scope == ImportScope.Unspecified);
writer.WriteStartElement("defaultnamespace");
writer.WriteAttributeString("name", target);
writer.WriteEndElement(); // </defaultnamespace>
break;
case ImportTargetKind.MethodToken:
Debug.Assert(alias == null);
Debug.Assert(externAlias == null);
Debug.Assert(scope == ImportScope.Unspecified);
int token = Convert.ToInt32(target);
writer.WriteStartElement("importsforward");
WriteMethodAttributes(token, isReference: true);
writer.WriteEndElement(); // </importsforward>
break;
case ImportTargetKind.XmlNamespace:
Debug.Assert(externAlias == null);
writer.WriteStartElement("xmlnamespace");
writer.WriteAttributeString("prefix", alias);
writer.WriteAttributeString("name", target);
WriteScopeAttribute(scope);
writer.WriteEndElement(); // </xmlnamespace>
break;
case ImportTargetKind.NamespaceOrType:
Debug.Assert(externAlias == null);
writer.WriteStartElement("alias");
writer.WriteAttributeString("name", alias);
writer.WriteAttributeString("target", target);
writer.WriteAttributeString("kind", "namespace"); // Strange, but retaining to avoid breaking tests.
WriteScopeAttribute(scope);
writer.WriteEndElement(); // </alias>
break;
case ImportTargetKind.Namespace:
if (alias != null)
{
writer.WriteStartElement("alias");
writer.WriteAttributeString("name", alias);
if (externAlias != null) writer.WriteAttributeString("qualifier", externAlias);
writer.WriteAttributeString("target", target);
writer.WriteAttributeString("kind", "namespace");
Debug.Assert(scope == ImportScope.Unspecified); // Only C# hits this case.
writer.WriteEndElement(); // </alias>
}
else
{
writer.WriteStartElement("namespace");
if (externAlias != null) writer.WriteAttributeString("qualifier", externAlias);
writer.WriteAttributeString("name", target);
WriteScopeAttribute(scope);
writer.WriteEndElement(); // </namespace>
}
break;
case ImportTargetKind.Type:
Debug.Assert(externAlias == null);
if (alias != null)
{
writer.WriteStartElement("alias");
writer.WriteAttributeString("name", alias);
writer.WriteAttributeString("target", target);
writer.WriteAttributeString("kind", "type");
Debug.Assert(scope == ImportScope.Unspecified); // Only C# hits this case.
writer.WriteEndElement(); // </alias>
}
else
{
writer.WriteStartElement("type");
writer.WriteAttributeString("name", target);
WriteScopeAttribute(scope);
writer.WriteEndElement(); // </type>
}
break;
case ImportTargetKind.Assembly:
Debug.Assert(alias == null);
Debug.Assert(scope == ImportScope.Unspecified);
if (target == null)
{
writer.WriteStartElement("extern");
writer.WriteAttributeString("alias", externAlias);
writer.WriteEndElement(); // </extern>
}
else
{
writer.WriteStartElement("externinfo");
writer.WriteAttributeString("alias", externAlias);
writer.WriteAttributeString("assembly", target);
writer.WriteEndElement(); // </externinfo>
}
break;
default:
Debug.Assert(false, "Unexpected import kind '" + kind + "'");
writer.WriteStartElement("unknown");
writer.WriteAttributeString("name", rawName);
writer.WriteEndElement(); // </unknown>
break;
}
}
public SymbolNamespaceImpl(ISymUnmanagedNamespace @namespace) => ns = @namespace;
public int GetNamespaces(int cNameSpaces, out int pcNameSpaces, ISymUnmanagedNamespace[] namespaces)
{
throw new NotImplementedException();
}
private void WriteNamespace(ISymUnmanagedNamespace @namespace)
{
string rawName = @namespace.GetName();
string alias;
string externAlias;
string target;
ImportTargetKind kind;
ImportScope scope;
try
{
if (rawName.Length == 0)
{
externAlias = null;
var parsingSucceeded = CDI.TryParseVisualBasicImportString(rawName, out alias, out target, out kind, out scope);
Debug.Assert(parsingSucceeded);
}
else
{
switch (rawName[0])
{
case 'U':
case 'A':
case 'X':
case 'Z':
case 'E':
case 'T':
scope = ImportScope.Unspecified;
if (!CDI.TryParseCSharpImportString(rawName, out alias, out externAlias, out target, out kind))
{
throw new InvalidOperationException(string.Format("Invalid import '{0}'", rawName));
}
break;
default:
externAlias = null;
if (!CDI.TryParseVisualBasicImportString(rawName, out alias, out target, out kind, out scope))
{
throw new InvalidOperationException(string.Format("Invalid import '{0}'", rawName));
}
break;
}
}
}
catch (ArgumentException) // TODO: filter
{
if ((options & PdbToXmlOptions.ThrowOnError) != 0)
{
throw;
}
writer.WriteStartElement("invalid-custom-data");
writer.WriteAttributeString("raw", rawName);
writer.WriteEndElement();
return;
}
switch (kind)
{
case ImportTargetKind.CurrentNamespace:
Debug.Assert(alias == null);
Debug.Assert(externAlias == null);
Debug.Assert(scope == ImportScope.Unspecified);
writer.WriteStartElement("currentnamespace");
writer.WriteAttributeString("name", target);
writer.WriteEndElement(); // </currentnamespace>
break;
case ImportTargetKind.DefaultNamespace:
Debug.Assert(alias == null);
Debug.Assert(externAlias == null);
Debug.Assert(scope == ImportScope.Unspecified);
writer.WriteStartElement("defaultnamespace");
writer.WriteAttributeString("name", target);
writer.WriteEndElement(); // </defaultnamespace>
break;
case ImportTargetKind.MethodToken:
Debug.Assert(alias == null);
Debug.Assert(externAlias == null);
Debug.Assert(scope == ImportScope.Unspecified);
int token = Convert.ToInt32(target);
writer.WriteStartElement("importsforward");
WriteMethodAttributes(token, isReference: true);
writer.WriteEndElement(); // </importsforward>
break;
case ImportTargetKind.XmlNamespace:
Debug.Assert(externAlias == null);
writer.WriteStartElement("xmlnamespace");
writer.WriteAttributeString("prefix", alias);
writer.WriteAttributeString("name", target);
WriteScopeAttribute(scope);
writer.WriteEndElement(); // </xmlnamespace>
break;
case ImportTargetKind.NamespaceOrType:
Debug.Assert(externAlias == null);
writer.WriteStartElement("alias");
writer.WriteAttributeString("name", alias);
writer.WriteAttributeString("target", target);
writer.WriteAttributeString("kind", "namespace"); // Strange, but retaining to avoid breaking tests.
WriteScopeAttribute(scope);
writer.WriteEndElement(); // </alias>
break;
case ImportTargetKind.Namespace:
if (alias != null)
{
writer.WriteStartElement("alias");
writer.WriteAttributeString("name", alias);
if (externAlias != null)
{
writer.WriteAttributeString("qualifier", externAlias);
}
writer.WriteAttributeString("target", target);
writer.WriteAttributeString("kind", "namespace");
Debug.Assert(scope == ImportScope.Unspecified); // Only C# hits this case.
writer.WriteEndElement(); // </alias>
}
else
{
writer.WriteStartElement("namespace");
if (externAlias != null)
{
writer.WriteAttributeString("qualifier", externAlias);
}
writer.WriteAttributeString("name", target);
WriteScopeAttribute(scope);
writer.WriteEndElement(); // </namespace>
}
break;
case ImportTargetKind.Type:
Debug.Assert(externAlias == null);
if (alias != null)
{
writer.WriteStartElement("alias");
writer.WriteAttributeString("name", alias);
writer.WriteAttributeString("target", target);
writer.WriteAttributeString("kind", "type");
Debug.Assert(scope == ImportScope.Unspecified); // Only C# hits this case.
writer.WriteEndElement(); // </alias>
}
else
{
writer.WriteStartElement("type");
writer.WriteAttributeString("name", target);
WriteScopeAttribute(scope);
writer.WriteEndElement(); // </type>
}
break;
case ImportTargetKind.Assembly:
Debug.Assert(alias == null);
Debug.Assert(scope == ImportScope.Unspecified);
if (target == null)
{
writer.WriteStartElement("extern");
writer.WriteAttributeString("alias", externAlias);
writer.WriteEndElement(); // </extern>
}
else
{
writer.WriteStartElement("externinfo");
writer.WriteAttributeString("alias", externAlias);
writer.WriteAttributeString("assembly", target);
writer.WriteEndElement(); // </externinfo>
}
break;
case ImportTargetKind.Defunct:
Debug.Assert(alias == null);
Debug.Assert(scope == ImportScope.Unspecified);
writer.WriteStartElement("defunct");
writer.WriteAttributeString("name", rawName);
writer.WriteEndElement(); // </defunct>
break;
default:
Debug.Assert(false, "Unexpected import kind '" + kind + "'");
writer.WriteStartElement("unknown");
writer.WriteAttributeString("name", rawName);
writer.WriteEndElement(); // </unknown>
break;
}
}
internal SymNamespace(ISymUnmanagedNamespace nameSpace)
{
m_unmanagedNamespace = nameSpace;
}
internal SymbolNamespace(ISymUnmanagedNamespace unNmsp)
{
private_namespace = unNmsp;
}
public ISymbolNamespace[] GetNamespaces()
{
int count = 0;
uint i;
m_reader.GetNamespaces(0, out count, null);
ISymUnmanagedNamespace[] unmanagedNamespaces = new ISymUnmanagedNamespace[count];
m_reader.GetNamespaces(count, out count, unmanagedNamespaces);
ISymbolNamespace[] namespaces = new SymNamespace[count];
for (i = 0; i < count; i++)
{
namespaces[i] = new SymNamespace(unmanagedNamespaces[i]);
}
return namespaces;
}
public int GetNamespaces(int cNameSpaces, out int pcNameSpaces, ISymUnmanagedNamespace[] namespaces)
{
pcNameSpaces = 0;
return SymUnmanagedReaderExtensions.E_NOTIMPL;
}
/// <summary>
/// Gets the namespaces that are used within the current scope
/// </summary>
/// <returns>The namespaces that are used within the current scope</returns>
public ISymbolNamespace[] GetNamespaces()
{
int nmNum;
private_scope.GetNamespaces(0, out nmNum, null);
ISymUnmanagedNamespace[] unNams = new ISymUnmanagedNamespace[nmNum];
ISymbolNamespace[] manNams = new ISymbolNamespace[nmNum];
private_scope.GetNamespaces(nmNum, out nmNum, unNams);
for (int i = 0; i < nmNum; i++)
manNams[i] = new SymbolNamespace(unNams[i]);
return manNams;
}
