internal static int GetSlot(this ISymUnmanagedVariable local)
{
int slot;
local.GetAddressField1(out slot);
return(slot);
}
internal static int GetAttributes(this ISymUnmanagedVariable local)
{
int result;
int hr = local.GetAttributes(out result);
ThrowExceptionForHR(hr);
return(result);
}
internal SymbolVariable(ISymUnmanagedVariable unmanagedVariable)
{
if (unmanagedVariable == null)
{
throw new ArgumentNullException("unmanagedVariable");
}
this.unmanagedVariable = unmanagedVariable;
}
internal SymbolVariable(ISymUnmanagedVariable unmanagedVariable)
{
if (unmanagedVariable == null)
{
throw new ArgumentNullException("unmanagedVariable");
}
this.unmanagedVariable = unmanagedVariable;
}
internal SymVariable(ISymUnmanagedVariable variable)
{
// We should not wrap null instances
if (variable == null)
throw new ArgumentNullException("variable");
m_unmanagedVariable = variable;
}
internal static int GetSlot(this ISymUnmanagedVariable local)
{
int result;
int hr = local.GetAddressField1(out result);
ThrowExceptionForHR(hr);
return(result);
}
internal static void VerifyLocalVariables(ISymUnmanagedEncUpdate symEncUpdate, int methodToken, params string[] expected)
{
Assert.Equal(HResult.S_OK, symEncUpdate.GetLocalVariableCount(methodToken, out int count));
var vars = new ISymUnmanagedVariable[count];
Assert.Equal(HResult.S_OK, symEncUpdate.GetLocalVariables(methodToken, count, vars, out count));
AssertEx.Equal(expected, vars.Select(v => v.GetName()));
}
public SymbolVariable(ISymUnmanagedVariable unmanaged)
{
if (unmanaged == null)
{
throw new ArgumentNullException("unmanaged");
}
_unmanaged = unmanaged;
}
public static ISymUnmanagedVariable[] GetLocals(this ISymUnmanagedScope symScope)
{
uint count;
symScope.GetLocals(0, out count, new ISymUnmanagedVariable[0]);
ISymUnmanagedVariable[] locals = new ISymUnmanagedVariable[count];
symScope.GetLocals(count, out count, locals);
return(locals);
}
internal static byte[] ToLocalSignature(this ISymUnmanagedVariable variable)
{
int n;
variable.GetSignature(0, out n, null);
var bytes = new byte[n];
variable.GetSignature(n, out n, bytes);
return(bytes);
}
public ISymbolVariable[] GetGlobalVariables() {
uint numVars;
reader.GetGlobalVariables(0, out numVars, null);
var unVars = new ISymUnmanagedVariable[numVars];
reader.GetGlobalVariables((uint)unVars.Length, out numVars, unVars);
var vars = new ISymbolVariable[numVars];
for (uint i = 0; i < numVars; i++)
vars[i] = new SymbolVariable(unVars[i]);
return vars;
}
LocalVariable GetLocalVariable(ISymUnmanagedVariable symVar)
{
return(new LocalVariable(
symVar.Name,
process,
new IExpirable[] { this },
new IMutable[] { process.DebugeeState },
delegate { return GetCorValueOfLocalVariable(symVar); }
));
}
public static string GetName(this ISymUnmanagedVariable local)
{
if (local == null)
{
throw new ArgumentNullException(nameof(local));
}
return(BufferToString(GetItems(local,
(ISymUnmanagedVariable a, int b, out int c, char[] d) => a.GetName(b, out c, d))));
}
public ISymbolVariable[] GetParameters() {
uint numVars;
method.GetParameters(0, out numVars, null);
var unVars = new ISymUnmanagedVariable[numVars];
method.GetParameters((uint)unVars.Length, out numVars, unVars);
var vars = new ISymbolVariable[numVars];
for (uint i = 0; i < numVars; i++)
vars[i] = new SymbolVariable(unVars[i]);
return vars;
}
internal SymVariable(ISymUnmanagedVariable variable)
{
// We should not wrap null instances
if (variable == null)
{
throw new ArgumentNullException("variable");
}
m_unmanagedVariable = variable;
}
private List <DebugLocalVariableInfo> GetLocalVariablesInScope(ISymUnmanagedScope symScope)
{
List <DebugLocalVariableInfo> vars = new List <DebugLocalVariableInfo>();
foreach (ISymUnmanagedVariable symVar in symScope.GetLocals())
{
ISymUnmanagedVariable symVarCopy = symVar;
int start;
SignatureReader sigReader = new SignatureReader(symVar.GetSignature());
LocalVarSig.LocalVariable locVarSig = sigReader.ReadLocalVariable(sigReader.Blob, 0, out start);
DebugType locVarType = DebugType.CreateFromSignature(this.DebugModule, locVarSig.Type, declaringType);
// Compiler generated?
// NB: Display class does not have the compiler-generated flag
if ((symVar.GetAttributes() & 1) == 1 || symVar.GetName().StartsWith("CS$"))
{
// Get display class from local variable
if (locVarType.IsDisplayClass)
{
AddCapturedLocalVariables(
vars,
(int)symScope.GetStartOffset(),
(int)symScope.GetEndOffset(),
delegate(StackFrame context)
{
return(GetLocalVariableValue(context, symVarCopy));
},
locVarType
);
}
}
else
{
DebugLocalVariableInfo locVar = new DebugLocalVariableInfo(
symVar.GetName(),
(int)symVar.GetAddressField1(),
// symVar also has Get*Offset methods, but the are not implemented
(int)symScope.GetStartOffset(),
(int)symScope.GetEndOffset(),
locVarType,
delegate(StackFrame context)
{
return(GetLocalVariableValue(context, symVarCopy));
}
);
vars.Add(locVar);
}
}
foreach (ISymUnmanagedScope childScope in symScope.GetChildren())
{
vars.AddRange(GetLocalVariablesInScope(childScope));
}
return(vars);
}
public ISymbolVariable[] GetGlobalVariables()
{
uint numVars;
reader.GetGlobalVariables(0, out numVars, null);
var unVars = new ISymUnmanagedVariable[numVars];
reader.GetGlobalVariables((uint)unVars.Length, out numVars, unVars);
var vars = new ISymbolVariable[numVars];
for (uint i = 0; i < numVars; i++)
vars[i] = new SymbolVariable(unVars[i]);
return vars;
}
public ISymbolVariable[] GetVariables(SymbolToken parent)
{
uint numVars;
reader.GetVariables((uint)parent.GetToken(), 0, out numVars, null);
var unVars = new ISymUnmanagedVariable[numVars];
reader.GetVariables((uint)parent.GetToken(), (uint)unVars.Length, out numVars, unVars);
var vars = new ISymbolVariable[numVars];
for (uint i = 0; i < numVars; i++)
vars[i] = new SymbolVariable(unVars[i]);
return vars;
}
public static int GetAttributes(this ISymUnmanagedVariable local)
{
if (local == null)
{
throw new ArgumentNullException(nameof(local));
}
int result;
ThrowExceptionForHR(local.GetAttributes(out result));
return(result);
}
ICorDebugValue GetLocalVariableCorValue(ISymUnmanagedVariable symVar)
{
try {
return(CorILFrame.GetLocalVariable((uint)symVar.AddressField1));
} catch (COMException e) {
if ((uint)e.ErrorCode == 0x80131304)
{
throw new GetValueException("Unavailable in optimized code");
}
throw;
}
}
public ISymbolVariable[] GetVariables(SymbolToken parent)
{
int varNm;
private_reader.GetVariables(parent, 0, out varNm, null);
ISymUnmanagedVariable[] unVars = new ISymUnmanagedVariable[varNm];
SymbolVariable[] retVal = new SymbolVariable[varNm];
private_reader.GetVariables(parent, varNm, out varNm, unVars);
for (int i = 0; i < varNm; i++)
{
retVal[i] = new SymbolVariable(unVars[i]);
}
return(retVal);
}
public static unsafe byte[] GetSignature(this ISymUnmanagedVariable symVar)
{
byte[] sig = new byte[defaultSigSize];
uint acualSize;
fixed(byte *pSig = sig)
symVar.GetSignature((uint)sig.Length, out acualSize, new IntPtr(pSig));
Array.Resize(ref sig, (int)acualSize);
if (acualSize > defaultSigSize)
fixed(byte *pSig = sig)
symVar.GetSignature((uint)sig.Length, out acualSize, new IntPtr(pSig));
return(sig);
}
public static ISymUnmanagedVariable[] GetAndValidateVariables(ISymUnmanagedScope scope, int expectedCount)
{
int count, count2, count3;
Assert.Equal(HResult.S_OK, scope.GetLocalCount(out count));
Assert.Equal(expectedCount, count);
Assert.Equal(HResult.S_OK, scope.GetLocals(0, out count2, null));
Assert.Equal(expectedCount, count2);
var variables = new ISymUnmanagedVariable[count];
Assert.Equal(HResult.S_OK, scope.GetLocals(count, out count3, variables));
Assert.Equal(count, count3);
return(variables);
}
public LocalVariableIdentifierExpression(MethodInfo method, ISymUnmanagedVariable symVar)
{
if (method == null)
{
throw new ArgumentNullException("method");
}
if (symVar == null)
{
throw new ArgumentNullException("symVar");
}
this.method = method;
this.symVar = symVar;
this.name = symVar.Name;
}
public ISymbolVariable[] GetVariables()
{
int cVars = 0;
uint i;
m_unmanagedNamespace.GetVariables(0, out cVars, null);
var unmanagedVariables = new ISymUnmanagedVariable[cVars];
m_unmanagedNamespace.GetVariables(cVars, out cVars, unmanagedVariables);
var Variables = new ISymbolVariable[cVars];
for (i = 0; i < cVars; i++)
{
Variables[i] = new SymVariable(unmanagedVariables[i]);
}
return Variables;
}
static Value GetLocalVariableValue(StackFrame context, ISymUnmanagedVariable symVar)
{
ICorDebugValue corVal;
try {
corVal = context.CorILFrame.GetLocalVariable((uint)symVar.GetAddressField1());
} catch (COMException e) {
if ((uint)e.ErrorCode == 0x80131304)
{
throw new GetValueException("Unavailable in optimized code");
}
throw;
}
return(new Value(context.AppDomain, corVal));
}
/// <summary>
/// Gets the local variables within the current lexical scope
/// </summary>
/// <returns>The local variables of the current scope</returns>
public ISymbolVariable[] GetLocals()
{
int lcNum;
private_scope.GetLocals(0, out lcNum, null);
ISymUnmanagedVariable[] unVars = new ISymUnmanagedVariable[lcNum];
ISymbolVariable[] manVars = new ISymbolVariable[lcNum];
private_scope.GetLocals(lcNum, out lcNum, unVars);
for (int i = 0; i < lcNum; i++)
{
manVars[i] = new SymbolVariable(unVars[i]);
}
return(manVars);
}
public ISymbolVariable[] GetLocals()
{
m_target.GetLocals(0, out var count, null);
ISymUnmanagedVariable[] uVariables = new ISymUnmanagedVariable[count];
m_target.GetLocals(count, out count, uVariables);
int i;
ISymbolVariable[] variables = new ISymbolVariable[count];
for (i = 0; i < count; i++)
{
variables[i] = new SymVariable(uVariables[i]);
}
return(variables);
}
public ISymbolVariable[] GetParameters()
{
uint numVars;
method.GetParameters(0, out numVars, null);
var unVars = new ISymUnmanagedVariable[numVars];
method.GetParameters((uint)unVars.Length, out numVars, unVars);
var vars = new ISymbolVariable[numVars];
for (uint i = 0; i < numVars; i++)
{
vars[i] = new SymbolVariable(unVars[i]);
}
return(vars);
}
public ISymbolVariable[] GetVariables()
{
int cVars = 0;
uint i;
m_unmanagedNamespace.GetVariables(0, out cVars, null);
ISymUnmanagedVariable[] unmanagedVariables = new ISymUnmanagedVariable[cVars];
m_unmanagedNamespace.GetVariables(cVars, out cVars, unmanagedVariables);
ISymbolVariable[] Variables = new ISymbolVariable[cVars];
for (i = 0; i < cVars; i++)
{
Variables[i] = new SymVariable(unmanagedVariables[i]);
}
return(Variables);
}
public ISymbolVariable[] GetVariables(SymbolToken parent)
{
int cVars = 0;
uint i;
m_reader.GetVariables(parent, 0, out cVars, null);
ISymUnmanagedVariable[] unmanagedVariables = new ISymUnmanagedVariable[cVars];
m_reader.GetVariables(parent, cVars, out cVars, unmanagedVariables);
SymVariable[] variables = new SymVariable[cVars];
for (i = 0; i < cVars; i++)
{
variables[i] = new SymVariable(unmanagedVariables[i]);
}
return(variables);
}
public ISymbolVariable[] GetGlobalVariables()
{
int cVars = 0;
uint i;
m_reader.GetGlobalVariables(0, out cVars, null);
ISymUnmanagedVariable[] unmanagedVariables = new ISymUnmanagedVariable[cVars];
m_reader.GetGlobalVariables(cVars, out cVars, unmanagedVariables);
SymVariable[] variables = new SymVariable[cVars];
for (i = 0; i < cVars; i++)
{
variables[i] = new SymVariable(unmanagedVariables[i]);
}
return(variables);
}
public ISymbolVariable[] GetParameters()
{
int cVariables;
uint i;
unmanagedMethod.GetParameters(0, out cVariables, null);
ISymUnmanagedVariable[] unmanagedVariables = new ISymUnmanagedVariable[cVariables];
unmanagedMethod.GetParameters(cVariables, out cVariables, unmanagedVariables);
ISymbolVariable[] variables = new ISymbolVariable[cVariables];
for (i = 0; i < cVariables; i++)
{
variables[i] = new SymbolVariable(unmanagedVariables[i]);
}
return(variables);
}
ICorDebugValue GetCorValueOfLocalVariable(ISymUnmanagedVariable symVar)
{
if (this.HasExpired)
{
throw new CannotGetValueException("FUNCTION_HAS_EXPIRED");
}
try {
return(CorILFrame.GetLocalVariable((uint)symVar.AddressField1));
} catch (COMException e) {
if ((uint)e.ErrorCode == 0x80131304)
{
throw new CannotGetValueException("Unavailable in optimized code");
}
throw;
}
}
public ISymbolVariable[] GetLocalVariables(SymbolToken mdMethodToken)
{
int count = 0;
((ISymUnmanagedEncUpdate)m_reader).GetLocalVariables(mdMethodToken, 0, null, out count);
ISymUnmanagedVariable[] unmanagedVariables = new ISymUnmanagedVariable[count];
((ISymUnmanagedEncUpdate)m_reader).GetLocalVariables(mdMethodToken, count, unmanagedVariables, out count);
ISymbolVariable[] variables = new ISymbolVariable[count];
uint i;
for (i = 0; i < count; i++)
{
variables[i] = new SymVariable(unmanagedVariables[i]);
}
return(variables);
}
internal override int GetLocals(int bufferLength, out int count, ISymUnmanagedVariable[] locals)
{
var mdReader = SymMethod.MetadataReader;
var scope = mdReader.GetLocalScope(_handle);
var handles = scope.GetLocalVariables();
int i = 0;
foreach (var handle in handles)
{
if (i >= bufferLength)
{
break;
}
locals[i++] = new SymVariable(SymMethod, handle);
}
count = (bufferLength == 0) ? handles.Count : i;
return HResult.S_OK;
}
public static ISymUnmanagedVariable[] GetAndValidateVariables(ISymUnmanagedScope scope, int expectedCount)
{
int count, count2, count3;
Assert.Equal(HResult.S_OK, scope.GetLocalCount(out count));
Assert.Equal(expectedCount, count);
Assert.Equal(HResult.S_OK, scope.GetLocals(0, out count2, null));
Assert.Equal(expectedCount, count2);
var variables = new ISymUnmanagedVariable[count];
Assert.Equal(HResult.S_OK, scope.GetLocals(count, out count3, variables));
Assert.Equal(count, count3);
return variables;
}
public static ISymUnmanagedVariable[] GetLocals(this ISymUnmanagedScope symScope)
{
uint count;
symScope.GetLocals(0, out count, new ISymUnmanagedVariable[0]);
ISymUnmanagedVariable[] locals = new ISymUnmanagedVariable[count];
symScope.GetLocals(count, out count, locals);
return locals;
}
static Value GetLocalVariableValue(StackFrame context, ISymUnmanagedVariable symVar)
{
ICorDebugValue corVal;
try {
corVal = context.CorILFrame.GetLocalVariable((uint)symVar.GetAddressField1());
} catch (COMException e) {
if ((uint)e.ErrorCode == 0x80131304) throw new GetValueException("Unavailable in optimized code");
throw;
}
return new Value(context.AppDomain, corVal);
}
internal SymVariable(ISymUnmanagedVariable variable)
{
m_unmanagedVariable = variable;
}
/// <summary>
/// Emits scope debugging symbols based on <c>ISymUnmanagedScope</c> insatnce, representing
/// scope from new assembly.
/// </summary>
/// <param name="smScope">Scope from new version of changed assembly.</param>
/// <param name="placeholder">Placeholder translation for local variables.</param>
public void EmitScope(ISymUnmanagedScope smScope, Dictionary<int, int> placeholder)
{
if(State != WriterState.Building){
throw new TranslatingException("ISym* interfaces were not initialized.");
}
uint scStartOffset = smScope.__GetStartOffset();
uint scEndOffset = smScope.__GetEndOffset();
mWriter.OpenScope(scStartOffset);
uint localsCount = smScope.__GetLocalCount();
if(localsCount > 0){
uint read;
ISymUnmanagedVariable[] variables = new ISymUnmanagedVariable[localsCount];
smScope.__GetLocals(localsCount,out read,variables);
for (int i = 0; i < localsCount; i++) {
byte[] signature = variables[i].GetSignature();
Signature sig = new Signature(signature);
sig.Migrate(translator);
signature = sig.Compress();
string name = variables[i].GetName();
uint addr1 = 0;//variables[i].GetAddressField1();
uint addr2 = 0;//variables[i].GetAddressField2();
uint addr3 = 0;//variables[i].GetAddressField3();
uint addrKind = variables[i].GetAddressKind();//variables[i].GetAddressKind();
if((variables[i].GetAttributes() & 1) != 1)
{
addr1 = variables[i].GetAddressField1();
addrKind = variables[i].GetAddressKind();
if (placeholder != null && placeholder.ContainsKey((int)addr1))
{
addr1 = (uint)placeholder[(int)addr1];
}
}
uint varStartOffset = scStartOffset;
uint varEndOffset = scEndOffset;
uint attributes = variables[i].GetAttributes();
IntPtr pName = Marshal.StringToCoTaskMemUni(name);
IntPtr pSig = Marshal.AllocCoTaskMem(signature.Length);
Marshal.Copy(signature,0,pSig,signature.Length);
try{
mWriter.DefineLocalVariable(pName,attributes,(uint)signature.Length,pSig,addrKind,
addr1,addr2,addr3,varStartOffset,varEndOffset);
} finally {
Marshal.FreeCoTaskMem(pSig);
Marshal.FreeCoTaskMem(pName);
}
}
}
ISymUnmanagedScope[] subScopes = smScope.GetChildren();
foreach(ISymUnmanagedScope subScope in subScopes){
EmitScope(subScope,placeholder);
}
mWriter.CloseScope(scEndOffset);
}
public ISymbolVariable[] GetLocalVariables(SymbolToken mdMethodToken)
{
int count = 0;
((ISymUnmanagedEncUpdate)m_reader).GetLocalVariables(mdMethodToken, 0, null, out count);
ISymUnmanagedVariable[] unmanagedVariables = new ISymUnmanagedVariable[count];
((ISymUnmanagedEncUpdate)m_reader).GetLocalVariables(mdMethodToken, count, unmanagedVariables, out count);
ISymbolVariable[] variables = new ISymbolVariable[count];
uint i;
for (i = 0; i < count; i++)
{
variables[i] = new SymVariable(unmanagedVariables[i]);
}
return variables;
}
public int GetGlobalVariables(int cVars, out int pcVars, ISymUnmanagedVariable[] vars)
{
throw new NotImplementedException();
}
public SymbolVariable(ISymUnmanagedVariable variable) {
this.variable = variable;
}
internal LocalVariable(ISymUnmanagedVariable symVariable)
{
SymVariable = symVariable;
}
public ISymbolVariable[] GetGlobalVariables()
{
int cVars = 0;
uint i;
m_reader.GetGlobalVariables(0, out cVars, null);
ISymUnmanagedVariable[] unmanagedVariables = new ISymUnmanagedVariable[cVars];
m_reader.GetGlobalVariables(cVars, out cVars, unmanagedVariables);
SymVariable[] variables = new SymVariable[cVars];
for (i = 0; i < cVars; i++)
{
variables[i] = new SymVariable(unmanagedVariables[i]);
}
return variables;
}
public static void GetLocals(this ISymUnmanagedScope instance, uint cLocals, out uint pcLocals, ISymUnmanagedVariable[] locals)
{
instance.__GetLocals(cLocals, out pcLocals, locals);
ProcessOutParameter(locals);
}
public ISymbolVariable[] GetParameters()
{
int cVariables = 0;
uint i;
m_unmanagedMethod.GetParameters(0, out cVariables, null);
var unmanagedVariables = new ISymUnmanagedVariable[cVariables];
m_unmanagedMethod.GetParameters(cVariables, out cVariables, unmanagedVariables);
var Variables = new ISymbolVariable[cVariables];
for (i = 0; i < cVariables; i++)
{
Variables[i] = new SymVariable(unmanagedVariables[i]);
}
return Variables;
}
static ICorDebugValue _FindLocal(string name, ICorDebugILFrame ilframe, ISymUnmanagedScope unmScope, uint ip)
{
int varcount;
unmScope.GetLocalCount(out varcount);
ISymUnmanagedVariable[] vars = new ISymUnmanagedVariable[varcount];
unmScope.GetLocals(varcount, out varcount, vars);
for (int iv = 0; iv < varcount; iv++)
{
ISymUnmanagedVariable var = vars[iv];
string varname;
{
int namelen;
var.GetName(0, out namelen, null);
StringBuilder sbName = new StringBuilder(namelen);
var.GetName(sbName.Capacity, out namelen, sbName);
namelen--; // Remove nul.
sbName.Length = namelen;
varname = sbName.ToString();
}
if (name == varname)
{
int field1;
var.GetAddressField1(out field1);
ICorDebugValue pvalue;
ilframe.GetLocalVariable((uint)field1, out pvalue);
return pvalue;
}
}
int cChildren;
unmScope.GetChildren(0, out cChildren, null);
ISymUnmanagedScope[] children = new ISymUnmanagedScope[cChildren];
unmScope.GetChildren(children.Length, out cChildren, children);
for (int ic = 0; ic < cChildren; ic++)
{
ICorDebugValue pvalue = _FindLocal(name, ilframe, children[ic], ip);
if (null != pvalue)
{
return pvalue;
}
}
return null;
}
internal override int GetLocals(int bufferLength, out int count, ISymUnmanagedVariable[] locals)
{
// C# and VB never define any locals in the root scope
count = 0;
return HResult.S_OK;
}
public int GetParameters(int cParams, out int pcParams, ISymUnmanagedVariable[] parms)
{
throw new NotImplementedException();
}
public int GetLocals(int cLocals, out int pcLocals, ISymUnmanagedVariable[] locals)
{
return _scope.GetLocals(cLocals, out pcLocals, locals);
}
internal SymbolVariable(ISymUnmanagedVariable unVar)
{
private_variable = unVar;
}
public ISymbolVariable[] GetLocals()
{
int count;
m_target.GetLocals(0, out count, null);
ISymUnmanagedVariable[] uVariables = new ISymUnmanagedVariable[count];
m_target.GetLocals(count, out count, uVariables);
int i;
ISymbolVariable[] variables = new ISymbolVariable[count];
for (i = 0; i < count; i++)
{
variables[i] = new SymVariable(uVariables[i]);
}
return variables;
}
public ISymbolVariable[] GetVariables(SymbolToken parent) {
uint numVars;
reader.GetVariables((uint)parent.GetToken(), 0, out numVars, null);
var unVars = new ISymUnmanagedVariable[numVars];
reader.GetVariables((uint)parent.GetToken(), (uint)unVars.Length, out numVars, unVars);
var vars = new ISymbolVariable[numVars];
for (uint i = 0; i < numVars; i++)
vars[i] = new SymbolVariable(unVars[i]);
return vars;
}
public ISymbolVariable[] GetVariables(SymbolToken parent)
{
int cVars = 0;
uint i;
m_reader.GetVariables(parent, 0, out cVars, null);
ISymUnmanagedVariable[] unmanagedVariables = new ISymUnmanagedVariable[cVars];
m_reader.GetVariables(parent, cVars, out cVars, unmanagedVariables);
SymVariable[] variables = new SymVariable[cVars];
for (i = 0; i < cVars; i++)
{
variables[i] = new SymVariable(unmanagedVariables[i]);
}
return variables;
}
static void _PrintLocals(ICorDebugILFrame ilframe, ISymUnmanagedScope unmScope, uint ip, System.IO.TextWriter writer)
{
int varcount;
unmScope.GetLocalCount(out varcount);
ISymUnmanagedVariable[] vars = new ISymUnmanagedVariable[varcount];
unmScope.GetLocals(varcount, out varcount, vars);
for (int iv = 0; iv < varcount; iv++)
{
ISymUnmanagedVariable var = vars[iv];
string varname;
{
int namelen;
var.GetName(0, out namelen, null);
StringBuilder sbName = new StringBuilder(namelen);
var.GetName(sbName.Capacity, out namelen, sbName);
namelen--; // Remove nul.
sbName.Length = namelen;
varname = sbName.ToString();
}
string valstr;
{
int field1;
var.GetAddressField1(out field1);
ICorDebugValue pvalue;
ilframe.GetLocalVariable((uint)field1, out pvalue);
valstr = ToString(pvalue);
}
writer.WriteLine("{0}={1}", varname, valstr);
}
int cChildren;
unmScope.GetChildren(0, out cChildren, null);
ISymUnmanagedScope[] children = new ISymUnmanagedScope[cChildren];
unmScope.GetChildren(children.Length, out cChildren, children);
for (int ic = 0; ic < cChildren; ic++)
{
_PrintLocals(ilframe, children[ic], ip, writer);
}
}
public static void ValidateVariable(ISymUnmanagedVariable variable, string name, int slot, LocalVariableAttributes attributes, byte[] signature)
{
int length, length2;
// name:
Assert.Equal(HResult.S_OK, variable.GetName(0, out length, null));
Assert.Equal(name.Length + 1, length);
var actualName = new char[length];
Assert.Equal(HResult.S_OK, variable.GetName(length, out length2, actualName));
Assert.Equal(length, length2);
Assert.Equal(name + "\0", new string(actualName));
int value;
Assert.Equal(HResult.S_OK, variable.GetAddressField1(out value));
Assert.Equal(slot, value);
Assert.Equal(HResult.E_NOTIMPL, variable.GetAddressField2(out value));
Assert.Equal(HResult.E_NOTIMPL, variable.GetAddressField3(out value));
Assert.Equal(HResult.E_NOTIMPL, variable.GetStartOffset(out value));
Assert.Equal(HResult.E_NOTIMPL, variable.GetEndOffset(out value));
Assert.Equal(HResult.S_OK, variable.GetAttributes(out value));
Assert.Equal(attributes, (LocalVariableAttributes)value);
Assert.Equal(HResult.S_OK, variable.GetAddressKind(out value));
Assert.Equal(1, value);
Assert.Equal(HResult.S_OK, variable.GetSignature(0, out length, null));
var actualSignature = new byte[length];
Assert.Equal(HResult.S_OK, variable.GetSignature(length, out length2, actualSignature));
Assert.Equal(length, length2);
AssertEx.Equal(signature, actualSignature);
}
//
// Gather the local details in a scope and then recurse to child scopes
//
private void ProbeScopeForLocals(List<ILLocalVariable> variables, ISymUnmanagedScope scope)
{
int localCount;
ThrowExceptionForHR(scope.GetLocalCount(out localCount));
ISymUnmanagedVariable[] locals = new ISymUnmanagedVariable[localCount];
ThrowExceptionForHR(scope.GetLocals(localCount, out localCount, locals));
for (int i = 0; i < localCount; i++)
{
var local = locals[i];
int slot;
ThrowExceptionForHR(local.GetAddressField1(out slot));
int nameLength;
ThrowExceptionForHR(local.GetName(0, out nameLength, null));
// nameLength includes terminating '\0'
char[] nameBuffer = new char[nameLength];
ThrowExceptionForHR(local.GetName(nameLength, out nameLength, nameBuffer));
int attributes;
ThrowExceptionForHR(local.GetAttributes(out attributes));
variables.Add(new ILLocalVariable() { Slot = slot, Name = new String(nameBuffer, 0, nameLength - 1), CompilerGenerated = (attributes & 0x1) != 0 });
}
int childrenCount;
ThrowExceptionForHR(scope.GetChildren(0, out childrenCount, null));
ISymUnmanagedScope[] children = new ISymUnmanagedScope[childrenCount];
ThrowExceptionForHR(scope.GetChildren(childrenCount, out childrenCount, children));
for (int i = 0; i < childrenCount; i++)
{
ProbeScopeForLocals(variables, children[i]);
}
}
public int GetVariables(SymbolToken parent, int cVars, out int pcVars, ISymUnmanagedVariable[] vars)
{
throw new NotImplementedException();
}
