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 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 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; }
internal SymConstant(ISymUnmanagedConstant constant, byte[] signatureOpt) { _constant = constant; _signatureOpt = signatureOpt; }