public void Write(MethodBody body, /*Telerik Authorship*/ MetadataToken methodToken, /*Telerik Authorship*/ MetadataToken localVarToken)
{
/*Telerik Authorship*/
//var method_token = body.Method.MetadataToken;
var sym_token = new SymbolToken(methodToken.ToInt32());
//var sym_token = new SymbolToken(body.Method.MetadataToken.ToInt32());
var instructions = CollectInstructions(body);
if (instructions.Count == 0)
{
return;
}
var start_offset = 0;
var end_offset = body.CodeSize;
writer.OpenMethod(sym_token);
writer.OpenScope(start_offset);
DefineSequencePoints(instructions);
/*Telerik Authorship*/
Dictionary <VariableDefinition, string> methodVariableDefinitionToNameMap =
GetMethodVariableDefinitionToNameMap(body.Method);
DefineVariables(body, /*Telerik Authorship*/ localVarToken, /*Telerik Authorship*/ methodVariableDefinitionToNameMap, start_offset, end_offset);
writer.CloseScope(end_offset);
writer.CloseMethod();
}
public void Write(MethodBody body)
{
var method_token = body.Method.MetadataToken;
var sym_token = new SymbolToken(method_token.ToInt32());
var instructions = CollectInstructions(body);
if (instructions.Count == 0)
{
return;
}
var start_offset = 0;
var end_offset = body.CodeSize;
writer.OpenMethod(sym_token);
writer.OpenScope(start_offset);
DefineSequencePoints(instructions);
DefineVariables(body, start_offset, end_offset);
writer.CloseScope(end_offset);
if (body.IteratorType != null)
{
DefineIteratorType(sym_token, body.IteratorType.Name);
}
if (body.iterator_scopes != null)
{
DefineIteratorScopes(sym_token, body.IteratorScopes, body.CodeSize);
}
writer.CloseMethod();
}
void DefineScope(ScopeDebugInformation scope, MethodDebugInformation info)
{
var start_offset = scope.Start.Offset;
var end_offset = scope.End.IsEndOfMethod
? info.code_size
: scope.End.Offset;
writer.OpenScope(start_offset);
var sym_token = new SymbolToken(info.local_var_token.ToInt32());
if (!scope.variables.IsNullOrEmpty())
{
for (int i = 0; i < scope.variables.Count; i++)
{
var variable = scope.variables [i];
CreateLocalVariable(variable, sym_token, start_offset, end_offset);
}
}
if (!scope.scopes.IsNullOrEmpty())
{
for (int i = 0; i < scope.scopes.Count; i++)
{
DefineScope(scope.scopes [i], info);
}
}
writer.CloseScope(end_offset);
}
void CreateScopes(MethodBody body, ScopeCollection scopes, SymbolToken localVarToken)
{
foreach (Scope s in scopes)
{
int startOffset = s.Start.Offset;
int endOffset = s.End == body.Instructions.Outside ?
body.Instructions[body.Instructions.Count - 1].Offset + 1 :
s.End.Offset;
m_writer.OpenScope(startOffset);
m_writer.UsingNamespace(body.Method.DeclaringType.Namespace);
m_writer.OpenNamespace(body.Method.DeclaringType.Namespace);
int start = body.Instructions.IndexOf(s.Start);
int end = s.End == body.Instructions.Outside ?
body.Instructions.Count - 1 :
body.Instructions.IndexOf(s.End);
ArrayList instructions = CollectSequencePoints(body, start, end);
DefineSequencePoints(instructions);
CreateLocalVariable(s, startOffset, endOffset, localVarToken);
CreateScopes(body, s.Scopes, localVarToken);
m_writer.CloseNamespace();
m_writer.CloseScope(endOffset);
}
}
public void Write(MethodBody body)
{
var method_token = body.Method.MetadataToken;
var sym_token = new SymbolToken(method_token.ToInt32());
var instructions = CollectInstructions(body);
if (instructions.Count == 0 && !body.HasVariables)
{
return;
}
var pdbSymbols = body.Symbols as PdbMethodSymbols;
writer.OpenMethod(sym_token);
DefineSequencePoints(instructions);
if (body.Scope != null)
{
WriteScope(body, body.Scope, true);
}
else
{
writer.OpenScope(0);
DefineUsedNamespaces(pdbSymbols);
if (body.HasVariables)
{
DefineVariables(body, body.Variables, 0, body.CodeSize);
}
writer.CloseScope(body.CodeSize);
}
DefineCustomMetadata(pdbSymbols);
writer.CloseMethod();
}
void DefineScope(ScopeDebugInformation scope, MethodDebugInformation info, out MetadataToken import_parent)
{
var start_offset = scope.Start.Offset;
var end_offset = scope.End.IsEndOfMethod
? info.code_size
: scope.End.Offset;
import_parent = new MetadataToken(0u);
writer.OpenScope(start_offset);
if (scope.Import != null && scope.Import.HasTargets && !import_info_to_parent.TryGetValue(info.scope.Import, out import_parent))
{
foreach (var target in scope.Import.Targets)
{
switch (target.Kind)
{
case ImportTargetKind.ImportNamespace:
writer.UsingNamespace("U" + target.@namespace);
break;
case ImportTargetKind.ImportType:
writer.UsingNamespace("T" + TypeParser.ToParseable(target.type));
break;
case ImportTargetKind.DefineNamespaceAlias:
writer.UsingNamespace("A" + target.Alias + " U" + target.@namespace);
break;
case ImportTargetKind.DefineTypeAlias:
writer.UsingNamespace("A" + target.Alias + " T" + TypeParser.ToParseable(target.type));
break;
}
}
import_info_to_parent.Add(info.scope.Import, info.method.MetadataToken);
}
var sym_token = info.local_var_token.ToInt32();
if (!scope.variables.IsNullOrEmpty())
{
for (int i = 0; i < scope.variables.Count; i++)
{
var variable = scope.variables [i];
DefineLocalVariable(variable, sym_token, start_offset, end_offset);
}
}
if (!scope.constants.IsNullOrEmpty())
{
for (int i = 0; i < scope.constants.Count; i++)
{
var constant = scope.constants [i];
DefineConstant(constant);
}
}
if (!scope.scopes.IsNullOrEmpty())
{
for (int i = 0; i < scope.scopes.Count; i++)
{
MetadataToken _;
DefineScope(scope.scopes [i], info, out _);
}
}
writer.CloseScope(end_offset);
}