public static void HideLineFromDebugger(this Instruction i, SequencePoint seqPoint) { if (seqPoint == null) return; HideLineFromDebugger(i, seqPoint.Document); }
private bool IsSignificantSequencePoint(Instruction ins, SequencePoint sp) { if (ins.OpCode == OpCodes.Nop) return false; if (ins.OpCode == OpCodes.Ret && ins.Next == null) return false; return sp.StartLine != HiddenLine; }
/// <summary> /// Initializes a new instance of <see cref="SequencePoint" />, copying /// data from the provided <see cref="Cil.SequencePoint" />. /// </summary> /// <param name="sequencePoint"> /// An instance of <see cref="Cil.SequencePoint" /> from which to copy /// property values. /// </param> public SequencePoint(Cil.SequencePoint sequencePoint) : this() { StartLine = sequencePoint.StartLine; StartColumn = sequencePoint.StartColumn; EndLine = sequencePoint.EndLine; EndColumn = sequencePoint.EndColumn; }
string CreateLeftLink(SequencePoint rightSP, FormattingInfo info, int offset = 0) { if (rightSP != null) { var rightSPUrl = CreateSequencePointUrl(info.LeftUrl, rightSP, offset); return String.Format("[ {0} ]", CreateMarkdownUrl("link", rightSPUrl)); } return ""; }
static void WriteSequencePoint (TextWriter writer, SequencePoint sequence_point) { writer.Write (".line {0},{1}:{2},{3} '{4}'", sequence_point.StartLine, sequence_point.EndLine, sequence_point.StartColumn, sequence_point.EndColumn, sequence_point.Document.Url); }
private SequencePoint CreateSequencePoint(Loc location) { var result = new SequencePoint(this.document); result.StartLine = 0; result.StartColumn = location.Position; // TODO: End location result.EndLine = 0; result.EndColumn = location.End; return result; }
public void LogError(string message, SequencePoint point = null) { if (point == null) { _weaver.LogError(message); } else { _weaver.LogErrorPoint(message, point); } }
void LogWarningPoint(string message, SequencePoint point) { if (point == null) { Logger.LogWarning(message); } else { Logger.LogWarning(message, point.Document.Url, point.StartLine, point.StartColumn, point.EndLine, point.EndColumn); } }
public void CreateMethodFromScratch() { IgnoreOnMono (); var module = ModuleDefinition.CreateModule ("Pan", ModuleKind.Dll); var type = new TypeDefinition ("Pin", "Pon", TypeAttributes.Public | TypeAttributes.Abstract | TypeAttributes.Sealed, module.ImportReference (typeof (object))); module.Types.Add (type); var method = new MethodDefinition ("Pang", MethodAttributes.Public | MethodAttributes.Static, module.ImportReference (typeof (string))); type.Methods.Add (method); var body = method.Body; body.InitLocals = true; var il = body.GetILProcessor (); var temp = new VariableDefinition (module.ImportReference (typeof (string))); body.Variables.Add (temp); il.Emit (OpCodes.Nop); il.Emit (OpCodes.Ldstr, "hello"); il.Emit (OpCodes.Stloc, temp); il.Emit (OpCodes.Ldloc, temp); il.Emit (OpCodes.Ret); var sequence_point = new SequencePoint (body.Instructions [0], new Document (@"C:\test.cs")) { StartLine = 0, StartColumn = 0, EndLine = 0, EndColumn = 4, }; method.DebugInformation.SequencePoints.Add (sequence_point); method.DebugInformation.Scope = new ScopeDebugInformation (body.Instructions [0], null) { Variables = { new VariableDebugInformation (temp, "temp") } }; var file = Path.Combine (Path.GetTempPath (), "Pan.dll"); module.Write (file, new WriterParameters { SymbolWriterProvider = new PdbWriterProvider (), }); module = ModuleDefinition.ReadModule (file, new ReaderParameters { SymbolReaderProvider = new PdbReaderProvider (), }); method = module.GetType ("Pin.Pon").GetMethod ("Pang"); Assert.AreEqual ("temp", method.DebugInformation.Scope.Variables [0].Name); }
private ICirFunction processMemberReference(ICirData cirData, IMemberReference memberDefinition, SequencePoint sequencePoint) { switch (memberDefinition.GetType().Name) { case "MethodReference": return processMethodReference(cirData, (MethodReference)memberDefinition, sequencePoint); case "MethodDefinition": return processMethodDefinition(cirData, (MethodDefinition)memberDefinition, sequencePoint); default: DI.log.error("in CirFactory.processMethodMember, unsupported MethodMember: {0}", memberDefinition.GetType().Name); break; } return null; }
public CirFunctionCall(ICirFunction _cirFunction, SequencePoint sequencePoint) : this(_cirFunction) { if (sequencePoint!=null) { fileName = sequencePoint.Document.Url; lineNumber = sequencePoint.StartLine; endLine = sequencePoint.EndLine; startColumn = sequencePoint.StartColumn; endColumn = sequencePoint.EndColumn; } else { } }
private static string ReadSourceLineFor(SequencePoint sp) { var lineContent = string.Empty; using (var fileStream = new FileStream(sp.Document.Url, FileMode.Open)) using (TextReader reader = new StreamReader(fileStream)) { //For some reason, sometimes StartLine holds an invalid line number. //in this case we are going to handle as if the source file is not available. for (var i = 0; i < sp.StartLine && lineContent != null; i++) { lineContent = reader.ReadLine(); } } return lineContent; }
private static string FormatSourceInformation(SequencePoint sp, Instruction instruction) { Func<SequencePoint, string> sequencePointFormater = delegate(SequencePoint s) { return string.Format("{0} ({1}, {2}) (IL instruction: {3} {4})", s.Document.Url, s.StartLine, s.StartColumn, instruction.OpCode, instruction.Operand); }; if (sp == null) return string.Format("{0} {1}", instruction.OpCode, instruction.Operand); if (!File.Exists(sp.Document.Url)) { return sequencePointFormater(sp); } string lineContent = ReadSourceLineFor(sp); return lineContent != null ? string.Format("{0} ({1}, {2}) : {3}", sp.Document.Url, sp.StartLine, sp.StartColumn, lineContent.Substring(sp.StartColumn - 1, sp.EndColumn - sp.StartColumn - 1)) : sequencePointFormater(sp); }
void InjectPropertyGetterGuard(MethodBody getBody, SequencePoint seqPoint, PropertyReference property) { var guardInstructions = new List<Instruction>(); var returnPoints = getBody.Instructions .Select((o, i) => new { o, i }) .Where(a => a.o.OpCode == OpCodes.Ret) .Select(a => a.i) .OrderByDescending(i => i); foreach (var ret in returnPoints) { var returnInstruction = getBody.Instructions[ret]; var errorMessage = string.Format(CultureInfo.InvariantCulture, ReturnValueOfPropertyIsNull, property.FullName); guardInstructions.Clear(); if (isDebug) { InstructionPatterns.DuplicateReturnValue(guardInstructions, property.PropertyType); InstructionPatterns.CallDebugAssertInstructions(guardInstructions, errorMessage); } InstructionPatterns.DuplicateReturnValue(guardInstructions, property.PropertyType); InstructionPatterns.IfNull(guardInstructions, returnInstruction, i => { // Clean up the stack since we're about to throw up. i.Add(Instruction.Create(OpCodes.Pop)); InstructionPatterns.LoadInvalidOperationException(i, errorMessage); // Throw the top item off the stack i.Add(Instruction.Create(OpCodes.Throw)); }); guardInstructions[0].HideLineFromDebugger(seqPoint); getBody.Instructions.Insert(ret, guardInstructions); } }
public string GetSourceCode(SequencePoint sequencePoint) { var lines = sourceCodeProvider.GetSourceCode(sequencePoint.Document.Url); if (lines == null) { return null; } if (sequencePoint.StartLine == sequencePoint.EndLine) { return lines[sequencePoint.StartLine - 1].Substring(sequencePoint.StartColumn - 1, sequencePoint.EndColumn - sequencePoint.StartColumn); } var list = new List<string>(); var startLine = sequencePoint.StartLine - 1; var endLine = sequencePoint.EndLine - 1; list.Add(lines[startLine].Substring(sequencePoint.StartColumn - 1)); for (var i = startLine + 1; i < endLine; i++) { list.Add(lines[i]); } var endColumn = sequencePoint.EndColumn - 1; var lastLine = lines[endLine]; if (endColumn < lastLine.Length) { list.Add(lastLine.Remove(endColumn)); } else { list.Add(lastLine); } return string.Join(" ", list.Select(x => x.Trim())); }
public MethodCalled(IMemberReference _memberReference, SequencePoint _sequencePoint) { memberReference = _memberReference; sequencePoint = _sequencePoint; }
private static string FormatSequencePoint (SequencePoint sp, bool exact) { return FormatSequencePoint (sp.Document.Url, sp.StartLine, sp.StartColumn, exact); }
SequencePoint TranslateSequencePoint(SequencePoint sequencePoint) { if (sequencePoint == null) return null; var document = new Document(Path.Combine(Path.GetDirectoryName(AssemblyFilePath), Path.GetFileName(sequencePoint.Document.Url))) { Language = sequencePoint.Document.Language, LanguageVendor = sequencePoint.Document.LanguageVendor, Type = sequencePoint.Document.Type, }; return new SequencePoint(document) { StartLine = sequencePoint.StartLine, StartColumn = sequencePoint.StartColumn, EndLine = sequencePoint.EndLine, EndColumn = sequencePoint.EndColumn, }; }
private void InjectPropertySetterGuard(MethodBody setBody, SequencePoint seqPoint, ParameterDefinition valueParameter, string errorMessage) { if (!valueParameter.MayNotBeNull()) return; var guardInstructions = new List<Instruction>(); var entry = setBody.Instructions.First(); if (isDebug) { InstructionPatterns.LoadArgumentOntoStack(guardInstructions, valueParameter); InstructionPatterns.CallDebugAssertInstructions(guardInstructions, errorMessage); } InstructionPatterns.LoadArgumentOntoStack(guardInstructions, valueParameter); InstructionPatterns.IfNull(guardInstructions, entry, i => { InstructionPatterns.LoadArgumentNullException(i, valueParameter.Name, errorMessage); // Throw the top item off the stack i.Add(Instruction.Create(OpCodes.Throw)); }); guardInstructions[0].HideLineFromDebugger(seqPoint); setBody.Instructions.Prepend(guardInstructions); }
private static Tuple <bool, TestId> IsSequencePointAtStartOfAUnitTest(RunStartParams rsp, Mono.Cecil.Cil.SequencePoint sp, FilePath assemblyPath, Func <DocumentLocation, IEnumerable <DTestCase> > findTest) { if (sp == null) { return(new Tuple <bool, TestId>(false, null)); } var dl = new DocumentLocation { document = PathBuilder.rebaseCodeFilePath(rsp.Solution.Path, rsp.Solution.SnapshotPath, FilePath.NewFilePath(sp.Document.Url)), line = DocumentCoordinate.NewDocumentCoordinate(sp.StartLine) }; var test = findTest(dl).FirstOrDefault(t => t.Source.Equals(assemblyPath)); if (test == null) { return(new Tuple <bool, TestId>(false, null)); } else { return(new Tuple <bool, TestId>( true, new TestId(assemblyPath, dl))); } }
void InjectMethodArgumentGuards(MethodDefinition method, MethodBody body, SequencePoint seqPoint) { var guardInstructions = new List<Instruction>(); foreach (var parameter in method.Parameters.Reverse()) { if (!parameter.MayNotBeNull()) continue; if (method.IsSetter && parameter.Equals(method.GetPropertySetterValueParameter())) continue; if (CheckForExistingGuard(body.Instructions, parameter)) continue; var entry = body.Instructions.First(); var errorMessage = string.Format(CultureInfo.InvariantCulture, IsNull, parameter.Name); guardInstructions.Clear(); if (isDebug) { InstructionPatterns.LoadArgumentOntoStack(guardInstructions, parameter); InstructionPatterns.CallDebugAssertInstructions(guardInstructions, errorMessage); } InstructionPatterns.LoadArgumentOntoStack(guardInstructions, parameter); InstructionPatterns.IfNull(guardInstructions, entry, i => { InstructionPatterns.LoadArgumentNullException(i, parameter.Name, errorMessage); // Throw the top item off the stack i.Add(Instruction.Create(OpCodes.Throw)); }); guardInstructions[0].HideLineFromDebugger(seqPoint); body.Instructions.Prepend(guardInstructions); } }
void InjectMethodReturnGuard(ValidationFlags localValidationFlags, MethodDefinition method, MethodBody body, SequencePoint seqPoint) { var guardInstructions = new List<Instruction>(); var returnPoints = body.Instructions .Select((o, ix) => new { o, ix }) .Where(a => a.o.OpCode == OpCodes.Ret) .Select(a => a.ix) .OrderByDescending(ix => ix); foreach (var ret in returnPoints) { if (localValidationFlags.HasFlag(ValidationFlags.ReturnValues) && !method.AllowsNullReturnValue() && method.ReturnType.IsRefType() && method.ReturnType.FullName != typeof(void).FullName && !method.IsGetter) { var errorMessage = string.Format(CultureInfo.InvariantCulture, ReturnValueOfMethodIsNull, method.FullName); AddReturnNullGuard(body.Instructions, seqPoint, ret, method.ReturnType, errorMessage, Instruction.Create(OpCodes.Throw)); } if (localValidationFlags.HasFlag(ValidationFlags.Arguments)) { foreach (var parameter in method.Parameters.Reverse()) { // This is no longer the return instruction location, but it is where we want to jump to. var returnInstruction = body.Instructions[ret]; if (localValidationFlags.HasFlag(ValidationFlags.OutValues) && parameter.IsOut && parameter.ParameterType.IsRefType() && !parameter.AllowsNull()) { var errorMessage = string.Format(CultureInfo.InvariantCulture, OutParameterIsNull, parameter.Name); guardInstructions.Clear(); if (isDebug) { InstructionPatterns.LoadArgumentOntoStack(guardInstructions, parameter); InstructionPatterns.CallDebugAssertInstructions(guardInstructions, errorMessage); } InstructionPatterns.LoadArgumentOntoStack(guardInstructions, parameter); InstructionPatterns.IfNull(guardInstructions, returnInstruction, i => { InstructionPatterns.LoadInvalidOperationException(i, errorMessage); // Throw the top item off the stack i.Add(Instruction.Create(OpCodes.Throw)); }); guardInstructions[0].HideLineFromDebugger(seqPoint); body.Instructions.Insert(ret, guardInstructions); } } } } }
private LocalizedString CreateLocalizedString (LanguageGender gender, SequencePoint sequencePoint) { var localized_string = new LocalizedString { Gender = gender }; if (sequencePoint != null) { localized_string.AddReference (RelativeDocumentUrl (sequencePoint.Document.Url), sequencePoint.StartLine); } if (StringAnalyzer.CheckFormatArguments (localized_string.UntranslatedSingularValue) || StringAnalyzer.CheckFormatArguments (localized_string.UntranslatedPluralValue)) { localized_string.StringFormatHint = "csharp-format"; } return localized_string; }
static void ReadLine(PdbLine line, Document document, MethodDebugInformation info) { var sequence_point = new SequencePoint ((int) line.offset, document); sequence_point.StartLine = (int) line.lineBegin; sequence_point.StartColumn = (int) line.colBegin; sequence_point.EndLine = (int) line.lineEnd; sequence_point.EndColumn = (int) line.colEnd; info.sequence_points.Add (sequence_point); }
/// <summary> /// Wrap the given sequence point which cn be null. /// </summary> public static ISourceLocation Wrap(SequencePoint sequencePoint) { return (sequencePoint != null) ? new SequencePointWrapper(sequencePoint) : null; }
/// <summary> /// Default ctor /// </summary> private SequencePointWrapper(SequencePoint sequencePoint) { this.sequencePoint = sequencePoint; }
private IEnumerable<LocalizedString> GenerateLocalizedStrings (SequencePoint sequencePoint, Stack<KeyValuePair<string, string>> parameters, bool gendered) { var neutral = CreateLocalizedString (LanguageGender.Neutral, sequencePoint); var masculine = CreateLocalizedString (LanguageGender.Masculine, sequencePoint); var feminine = CreateLocalizedString (LanguageGender.Feminine, sequencePoint); while (parameters.Count > 0) { var param = parameters.Pop (); switch (param.Key) { case "comment": neutral.DeveloperComments = param.Value; masculine.DeveloperComments = param.Value; feminine.DeveloperComments = param.Value; break; case "message": case "singularMessage": if (gendered) { masculine.UntranslatedSingularValue = param.Value; feminine.UntranslatedSingularValue = param.Value; } neutral.UntranslatedSingularValue = param.Value; break; case "pluralMessage": if (gendered) { masculine.UntranslatedPluralValue = param.Value; feminine.UntranslatedPluralValue = param.Value; } neutral.UntranslatedPluralValue = param.Value; break; case "masculineMessage": case "singularMasculineMessage": masculine.UntranslatedSingularValue = param.Value; break; case "pluralMasculineMessage": masculine.UntranslatedPluralValue = param.Value; break; case "feminineMessage": case "singularFeminineMessage": feminine.UntranslatedSingularValue = param.Value; break; case "pluralFeminineMessage": feminine.UntranslatedPluralValue = param.Value; break; } } if (neutral.IsDefined) { yield return neutral; } if (masculine.IsDefined) { yield return masculine; } if (feminine.IsDefined) { yield return feminine; } }
static void ReadLine(PdbLine line, Document document, InstructionMapper mapper) { var instruction = mapper ((int) line.offset); if (instruction == null) return; var sequence_point = new SequencePoint (document); sequence_point.StartLine = (int) line.lineBegin; sequence_point.StartColumn = (int) line.colBegin; sequence_point.EndLine = (int) line.lineEnd; sequence_point.EndColumn = (int) line.colEnd; instruction.SequencePoint = sequence_point; }
public ICirFunction processMethodDefinition(ICirData cirData, MethodDefinition methodDefinition, SequencePoint sequencePoint) { try { //var functionSignature = methodDefinition.ToString(); var functionSignature = CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference(methodDefinition); var functionClass = CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(methodDefinition.DeclaringType); var cirFunction = getCirFunction(cirData, functionSignature, functionClass); if (false == cirFunction.HasBeenProcessedByCirFactory) { if (methodDefinition.CustomAttributes != null && methodDefinition.CustomAttributes.Count > 0) { foreach (CustomAttribute customAttribute in methodDefinition.CustomAttributes) { var constructorSignature = CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference(customAttribute.Constructor); var cirAttribute = new CirAttribute(constructorSignature); foreach (var constructorParameter in customAttribute.ConstructorParameters) { var type = constructorParameter.GetType().FullName; } if (customAttribute.Fields.Count > 0 || customAttribute.Properties.Count > 0) { } // PublicDI.log.debug("Added attribute {0} to {1}", customAttribute.Constructor.Name, cirFunction.FunctionName); cirFunction.FunctionAttributes.Add(cirAttribute); } } // map the common values with MethodReference processMethodReference(cirData, methodDefinition, sequencePoint); cirFunction.HasBeenProcessedByCirFactory = true; // we need to put this in here or we will have an infinite loop on recursive functions cirFunction.HasControlFlowGraph = true; // ControlFlowGraph is use by the Viewers to determine if we have more than just a reference to this method cirFunction.ParentClass.bClassHasMethodsWithControlFlowGraphs = true; // also mark the parent class cirFunction.IsStatic = methodDefinition.IsStatic; cirFunction.IsUnmanaged = methodDefinition.IsUnmanaged; cirFunction.IsUnmanagedExport = methodDefinition.IsUnmanagedExport; cirFunction.IsVirtual = methodDefinition.IsVirtual; cirFunction.IsSetter = methodDefinition.IsSetter; cirFunction.IsGetter = methodDefinition.IsGetter; cirFunction.IsRuntime = methodDefinition.IsRuntime; cirFunction.IsPublic = methodDefinition.IsPublic; cirFunction.IsPrivate = methodDefinition.IsPrivate; cirFunction.IsPInvokeImpl = methodDefinition.IsPInvokeImpl; cirFunction.IsNative = methodDefinition.IsNative; cirFunction.IsManaged = methodDefinition.IsManaged; cirFunction.IsInternalCall = methodDefinition.IsInternalCall; cirFunction.IsIL = methodDefinition.IsIL; cirFunction.IsConstructor = methodDefinition.IsConstructor; cirFunction.IsAbstract = methodDefinition.IsAbstract; cirFunction.HasSecurity = methodDefinition.HasSecurity; cirFunction.HasBody = methodDefinition.HasBody; // try to find the location of the current method by going for the first line of the first method if (methodDefinition.HasBody) foreach (Instruction instruction in methodDefinition.Body.Instructions) if (instruction.SequencePoint != null ) { cirFunction.File = instruction.SequencePoint.Document.Url; if (instruction.SequencePoint.StartLine == 16707566) // means there is no source code ref cirFunction.FileLine = "0"; else cirFunction.FileLine = instruction.SequencePoint.StartLine.ToString(); break; } // map method parameters (this could be on the MethodReference but if so we would have to check for doing it more than once: foreach (ParameterDefinition parameter in methodDefinition.Parameters) { ICirFunctionParameter functionParameter = new CirFunctionParameter { ParameterName = parameter.ToString(), ParameterType = parameter.ParameterType.FullName, Constant = (parameter.Constant != null) ? parameter.Constant.ToString() : "", HasConstant = parameter.HasConstant, HasDefault = parameter.HasDefault, Method = parameter.Method.ToString() }; cirFunction.FunctionParameters.Add(functionParameter); } // map the calls made and the IsCalledBy foreach (var methodCalled in CecilUtils.getMethodsCalledInsideMethod(methodDefinition)) { ICirFunction cirCalledFunction = processMemberReference(cirData, methodCalled.memberReference, methodCalled.sequencePoint); if (cirCalledFunction != null) { // store the fucntion called sequence cirFunction.FunctionsCalled.Add(new CirFunctionCall(cirCalledFunction,methodCalled.sequencePoint)); // store the unique list of funcions called if (false == cirFunction.FunctionsCalledUniqueList.Contains(cirCalledFunction)) cirFunction.FunctionsCalledUniqueList.Add(cirCalledFunction); // map the FunctionCalled and FunctionIsCalledBy var cirFunctionCall = new CirFunctionCall(cirCalledFunction, sequencePoint); //cirFunction.FunctionsCalled.Add(cirFunctionCall); cirCalledFunction.FunctionIsCalledBy.Add(cirFunctionCall); //if (false == cirCalledFunction.FunctionIsCalledBy.Contains(cirFunction)) // cirCalledFunction.FunctionIsCalledBy.Add(cirFunction); } } } // to implement if needed /* foreach (var methodOverride in methodDefinition.Overrides) { var name = methodOverride.GetType(); }*/ return cirFunction; } catch (Exception ex) { DI.log.ex(ex, "in CirFactory.processMethodDefinition", true); return null; } }
private string Sequence(SequencePoint point) { return point == null ? "NULL" : string.Format("{0}[{1}]-{2}[{3}] <{4}>", point.StartLine, point.StartColumn, point.EndLine, point.EndColumn, point.Document.Url); }
public ICirFunction processMethodReference(ICirData cirData, MethodReference methodReference, SequencePoint sequencePoint) { try { var functionSignature = CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference(methodReference); var functionType = CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(methodReference.DeclaringType); var cirFunction = getCirFunction(cirData, functionSignature, functionType); cirFunction.CecilSignature = methodReference.ToString(); cirFunction.ReturnType = methodReference.ReturnType.ReturnType.FullName; cirFunction.ParentClass = getCirClass(cirData, CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(methodReference.DeclaringType)); cirFunction.ParentClassFullName = methodReference.DeclaringType.FullName; cirFunction.ParentClassName = methodReference.DeclaringType.Name; // cirFunction.Module = (methodReference.DeclaringType.Module != null) ? methodReference.DeclaringType.Module.Assembly.ToString() : "[NullModule]"; //cirFunction.Module = (methodReference.DeclaringType.Module != null) ? methodReference.DeclaringType.Module.Name : "[NullModule]"; cirFunction.FunctionName = methodReference.Name; cirFunction.FunctionNameAndParameters = CecilUtils.getMethodNameAndParameters(methodReference); cirFunction.ClassNameFunctionNameAndParameters = string.Format("{0}.{1}", cirFunction.ParentClassFullName, cirFunction.FunctionNameAndParameters); cirFunction.SymbolDef = Guid.NewGuid().ToString(); /*if (sequencePoint != null) { if (string.IsNullOrEmpty(cirFunction.File) == false) { } cirFunction.File = sequencePoint.Document.Url; cirFunction.FileLine = sequencePoint.StartColumn.ToString(); }*/ //methodReference.ReturnType // to implement since we need to add reference to a CirClass return cirFunction; } catch (Exception ex) { DI.log.ex(ex, "in CirFactory.processMethodReference", true); return null; } }
public InstructionSymbol(int offset, SequencePoint sequencePoint) { this.Offset = offset; this.SequencePoint = sequencePoint; }
static internal string GetIdentifier(Cil.SequencePoint sequencePoint) { return(GetIdentifier(sequencePoint.StartLine, sequencePoint.StartColumn, sequencePoint.EndLine, sequencePoint.EndColumn)); }