public static void onBeforeExpand(TreeNode selectedTreeNode, O2Thread.FuncVoidT1T2T3T4 <ICirFunctionCall, TreeNode, bool, bool> addToNodeFunction, bool dontAddRecursiveCalls) { if (selectedTreeNode != null) { ICirFunctionCall functionCall = null; if (selectedTreeNode.Tag is ICirFunctionCall) { functionCall = (ICirFunctionCall)selectedTreeNode.Tag; //addToNode_MakesCallsTo(functionCall, selectedTreeNode, false); } else if (selectedTreeNode.Tag is ICirFunction) { selectedTreeNode.Nodes.Clear(); functionCall = new CirFunctionCall((ICirFunction)selectedTreeNode.Tag); } if (functionCall != null) { selectedTreeNode.Nodes.Clear(); addToNodeFunction(functionCall, selectedTreeNode, false, dontAddRecursiveCalls); } } }
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); } }