public static void ValidateConstant(ISymUnmanagedConstant constant, string name, object value, byte[] signature)
{
int length, length2;
// name:
Assert.Equal(HResult.S_OK, constant.GetName(0, out length, null));
Assert.Equal(name.Length + 1, length);
var actualName = new char[length];
Assert.Equal(HResult.S_OK, constant.GetName(length, out length2, actualName));
Assert.Equal(length, length2);
Assert.Equal(name + "\0", new string(actualName));
// value:
object actualValue;
Assert.Equal(HResult.S_OK, constant.GetValue(out actualValue));
Assert.Equal(value, actualValue);
// signature:
Assert.Equal(HResult.S_OK, constant.GetSignature(0, out length, null));
var actualSignature = new byte[length];
Assert.Equal(HResult.S_OK, constant.GetSignature(length, out length2, actualSignature));
Assert.Equal(length, length2);
AssertEx.Equal(signature, actualSignature);
}
public override IList <PdbConstant> GetConstants(ModuleDef module, GenericParamContext gpContext)
{
if (scope is not ISymUnmanagedScope2 scope2)
{
return(Array2.Empty <PdbConstant>());
}
scope2.GetConstants(0, out uint numCs, null);
if (numCs == 0)
{
return(Array2.Empty <PdbConstant>());
}
var unCs = new ISymUnmanagedConstant[numCs];
scope2.GetConstants((uint)unCs.Length, out numCs, unCs);
var nss = new PdbConstant[numCs];
for (uint i = 0; i < numCs; i++)
{
var unc = unCs[i];
var name = GetName(unc);
unc.GetValue(out object value);
var sigBytes = GetSignatureBytes(unc);
TypeSig signature;
if (sigBytes.Length == 0)
{
signature = null;
}
else
{
signature = SignatureReader.ReadTypeSig(module, module.CorLibTypes, sigBytes, gpContext);
}
nss[i] = new PdbConstant(name, signature, value);
}
return(nss);
}
public SymbolConstant(ISymUnmanagedConstant unmanagedConstant)
{
if (unmanagedConstant == null)
{
throw new ArgumentNullException("unmanagedConstant");
}
this.unmanagedConstant = unmanagedConstant;
}
public SymConstant(ISymUnmanagedConstant target)
{
// We should not wrap null instances
if (target == null)
throw new ArgumentNullException("target");
m_target = target;
}
public SymbolConstant(ISymUnmanagedConstant unmanagedConstant)
{
if (unmanagedConstant == null)
{
throw new ArgumentNullException("unmanagedConstant");
}
this.unmanagedConstant = unmanagedConstant;
}
public static object GetValue(this ISymUnmanagedConstant constant)
{
object value;
int hr = constant.GetValue(out value);
ThrowExceptionForHR(hr);
return(value);
}
public static byte[] GetSignature(this ISymUnmanagedConstant constant)
{
if (constant == null)
{
throw new ArgumentNullException(nameof(constant));
}
return(NullToEmpty(GetItems(constant,
(ISymUnmanagedConstant a, int b, out int c, byte[] d) => a.GetSignature(b, out c, d))));
}
public static string GetName(this ISymUnmanagedConstant constant)
{
if (constant == null)
{
throw new ArgumentNullException(nameof(constant));
}
return(BufferToString(GetItems(constant,
(ISymUnmanagedConstant a, int b, out int c, char[] d) => a.GetName(b, out c, d))));
}
public SymConstant(ISymUnmanagedConstant target)
{
// We should not wrap null instances
if (target == null)
{
throw new ArgumentNullException("target");
}
m_target = target;
}
public static object GetValue(this ISymUnmanagedConstant constant)
{
if (constant == null)
{
throw new ArgumentNullException(nameof(constant));
}
object value;
ThrowExceptionForHR(constant.GetValue(out value));
return(value);
}
public static ISymUnmanagedConstant[] GetAndValidateConstants(ISymUnmanagedScope scope, int expectedCount)
{
int count, count2;
Assert.Equal(HResult.S_OK, ((ISymUnmanagedScope2)scope).GetConstants(0, out count, null));
Assert.Equal(expectedCount, count);
var constants = new ISymUnmanagedConstant[count];
Assert.Equal(HResult.S_OK, ((ISymUnmanagedScope2)scope).GetConstants(count, out count2, constants));
Assert.Equal(count, count2);
return(constants);
}
string GetName(ISymUnmanagedConstant unc)
{
unc.GetName(0, out uint count, null);
var chars = new char[count];
unc.GetName((uint)chars.Length, out count, chars);
if (chars.Length == 0)
{
return(string.Empty);
}
return(new string(chars, 0, chars.Length - 1));
}
public ISymbolConstant[] GetConstants()
{
((ISymUnmanagedScope2)m_target).GetConstants(0, out var count, null);
ISymUnmanagedConstant[] uConstants = new ISymUnmanagedConstant[count];
((ISymUnmanagedScope2)m_target).GetConstants(count, out count, uConstants);
int i;
ISymbolConstant[] Constants = new ISymbolConstant[count];
for (i = 0; i < count; i++)
{
Constants[i] = new SymConstant(uConstants[i]);
}
return(Constants);
}
private static ISymUnmanagedConstant[] GetConstants(this ISymUnmanagedScope2 scope)
{
int length;
scope.GetConstants(0, out length, null);
if (length == 0)
{
return(null);
}
var constants = new ISymUnmanagedConstant[length];
scope.GetConstants(length, out length, constants);
return(constants);
}
public Builder(string[][] importStringGroups = null, bool suppressUsingInfo = false, ISymUnmanagedConstant[] constants = null)
{
_bytesBuilder = ArrayBuilder<byte>.GetInstance();
if (importStringGroups != null && !suppressUsingInfo)
{
var groupSizes = importStringGroups.Select(g => (short)g.Length).ToArray();
AddUsingInfo(groupSizes);
}
var namespaces = importStringGroups == null
? default(ImmutableArray<ISymUnmanagedNamespace>)
: importStringGroups.SelectMany(names => names.Select(name => (ISymUnmanagedNamespace)new MockSymUnmanagedNamespace(name))).ToImmutableArray();
var childScope = new MockSymUnmanagedScope(default(ImmutableArray<ISymUnmanagedScope>), namespaces, constants);
var rootScope = new MockSymUnmanagedScope(ImmutableArray.Create<ISymUnmanagedScope>(childScope), default(ImmutableArray<ISymUnmanagedNamespace>));
_method = new MockSymUnmanagedMethod(rootScope);
}
public ISymbolConstant[] GetConstants()
{
int count;
((ISymUnmanagedScope2)unmanagedScope).GetConstants(0, out count, null);
ISymUnmanagedConstant[] uConstants = new ISymUnmanagedConstant[count];
((ISymUnmanagedScope2)unmanagedScope).GetConstants(count, out count, uConstants);
int i;
ISymbolConstant[] constants = new ISymbolConstant[count];
for (i = 0; i < count; i++)
{
constants[i] = new SymbolConstant(uConstants[i]);
}
return(constants);
}
byte[] GetSignatureBytes(ISymUnmanagedConstant unc)
{
const int E_FAIL = unchecked ((int)0x80004005);
const int E_NOTIMPL = unchecked ((int)0x80004001);
int hr = unc.GetSignature(0, out uint bufSize, null);
if (bufSize == 0 || (hr < 0 && hr != E_FAIL && hr != E_NOTIMPL))
{
return(Array2.Empty <byte>());
}
var buffer = new byte[bufSize];
hr = unc.GetSignature((uint)buffer.Length, out bufSize, buffer);
Debug.Assert(hr == 0);
if (hr != 0)
{
return(Array2.Empty <byte>());
}
return(buffer);
}
private static bool TryGetConstantValue(this ISymUnmanagedConstant constant, out NamedLocalConstant value)
{
value = default(NamedLocalConstant);
int length;
int hresult = constant.GetName(0, out length, null);
SymUnmanagedReaderExtensions.ThrowExceptionForHR(hresult);
Debug.Assert(length > 0);
if (length == 0)
{
return(false);
}
var chars = new char[length];
hresult = constant.GetName(length, out length, chars);
SymUnmanagedReaderExtensions.ThrowExceptionForHR(hresult);
Debug.Assert(chars[length - 1] == 0);
var name = new string(chars, 0, length - 1);
constant.GetSignature(0, out length, null);
Debug.Assert(length > 0);
if (length == 0)
{
return(false);
}
var signature = new byte[length];
constant.GetSignature(length, out length, signature);
object val;
constant.GetValue(out val);
var constantValue = GetConstantValue(signature, val);
value = new NamedLocalConstant(name, signature, constantValue);
return(true);
}
public PdbConstant[] GetConstants(ModuleDefMD module, GenericParamContext gpContext)
{
var scope2 = scope as ISymUnmanagedScope2;
if (scope2 == null)
{
return(emptySymbolConstants);
}
uint numCs;
scope2.GetConstants(0, out numCs, null);
if (numCs == 0)
{
return(emptySymbolConstants);
}
var unCs = new ISymUnmanagedConstant[numCs];
scope2.GetConstants((uint)unCs.Length, out numCs, unCs);
var nss = new PdbConstant[numCs];
for (uint i = 0; i < numCs; i++)
{
var unc = unCs[i];
var name = GetName(unc);
object value;
unc.GetValue(out value);
var sigBytes = GetSignatureBytes(unc);
TypeSig signature;
if (sigBytes.Length == 0)
{
signature = null;
}
else
{
signature = SignatureReader.ReadTypeSig(module, module.CorLibTypes, sigBytes, gpContext);
}
nss[i] = new PdbConstant(name, signature, value);
}
return(nss);
}
internal override int GetConstants(int bufferLength, out int count, ISymUnmanagedConstant[] constants)
{
var symReader = SymMethod.SymReader;
var mdReader = symReader.MetadataReader;
var scope = mdReader.GetLocalScope(_handle);
var handles = scope.GetLocalConstants();
int i = 0;
foreach (var handle in handles)
{
if (i >= bufferLength)
{
break;
}
constants[i++] = new SymConstant(symReader, handle);
}
count = (bufferLength == 0) ? handles.Count : i;
return HResult.S_OK;
}
public static void ValidateConstant(ISymUnmanagedConstant constant, string name, object value, byte[] signature)
{
int length, length2;
// name:
Assert.Equal(HResult.S_OK, constant.GetName(0, out length, null));
Assert.Equal(name.Length + 1, length);
var actualName = new char[length];
Assert.Equal(HResult.S_OK, constant.GetName(length, out length2, actualName));
Assert.Equal(length, length2);
Assert.Equal(name + "\0", new string(actualName));
// value:
object actualValue;
Assert.Equal(HResult.S_OK, constant.GetValue(out actualValue));
Assert.Equal(value, actualValue);
// signature:
Assert.Equal(HResult.S_OK, constant.GetSignature(0, out length, null));
var actualSignature = new byte[length];
Assert.Equal(HResult.S_OK, constant.GetSignature(length, out length2, actualSignature));
Assert.Equal(length, length2);
AssertEx.Equal(signature, actualSignature);
}
public static ISymUnmanagedConstant[] GetAndValidateConstants(ISymUnmanagedScope scope, int expectedCount)
{
int count, count2;
Assert.Equal(HResult.S_OK, ((ISymUnmanagedScope2)scope).GetConstants(0, out count, null));
Assert.Equal(expectedCount, count);
var constants = new ISymUnmanagedConstant[count];
Assert.Equal(HResult.S_OK, ((ISymUnmanagedScope2)scope).GetConstants(count, out count2, constants));
Assert.Equal(count, count2);
return constants;
}
public SymConstant(ISymUnmanagedConstant target)
{
m_target = target;
}
internal abstract int GetConstants(int bufferLength, out int count, ISymUnmanagedConstant[] constants);
public static ImmutableArray <byte> GetSignature(this ISymUnmanagedConstant constant)
{
return(ToImmutableOrEmpty(GetItems(constant,
(ISymUnmanagedConstant a, int b, out int c, byte[] d) => a.GetSignature(b, out c, d))));
}
public ISymbolConstant[] GetConstants()
{
int count;
((ISymUnmanagedScope2)m_target).GetConstants(0, out count, null);
ISymUnmanagedConstant[] uConstants = new ISymUnmanagedConstant[count];
((ISymUnmanagedScope2)m_target).GetConstants(count, out count, uConstants);
int i;
ISymbolConstant[] Constants = new ISymbolConstant[count];
for (i = 0; i < count; i++)
{
Constants[i] = new SymConstant(uConstants[i]);
}
return Constants;
}
public static string GetName(this ISymUnmanagedConstant constant)
{
return(ToString(GetItems(constant,
(ISymUnmanagedConstant a, int b, out int c, char[] d) => a.GetName(b, out c, d))));
}
public int GetConstants(int cConstants, out int pcConstants, ISymUnmanagedConstant[] constants)
{
((ISymUnmanagedScope2)_scope).GetConstants(cConstants, out pcConstants, constants);
if (constants != null)
{
for (int i = 0; i < pcConstants; i++)
{
var c = constants[i];
var signaturesOpt = _reader._constantSignaturesOpt;
byte[] signature = null;
if (signaturesOpt != null)
{
int length;
int hresult = c.GetName(0, out length, null);
SymUnmanagedReaderExtensions.ThrowExceptionForHR(hresult);
var chars = new char[length];
hresult = c.GetName(length, out length, chars);
SymUnmanagedReaderExtensions.ThrowExceptionForHR(hresult);
var name = new string(chars, 0, length - 1);
signaturesOpt.TryGetValue(name, out signature);
}
constants[i] = new SymConstant(c, signature);
}
}
return SymUnmanagedReaderExtensions.S_OK;
}
internal override int GetConstants(int bufferLength, out int count, ISymUnmanagedConstant[] constants)
{
// C# and VB never define any constants in the root scope
count = 0;
return HResult.S_OK;
}
public SymConstant(ISymUnmanagedConstant target)
{
m_target = target;
}
internal SymConstant(ISymUnmanagedConstant constant, byte[] signatureOpt)
{
_constant = constant;
_signatureOpt = signatureOpt;
}
internal SymConstant(ISymUnmanagedConstant constant, byte[] signatureOpt)
{
_constant = constant;
_signatureOpt = signatureOpt;
}
