public ICirClass processTypeDefinition(ICirData cirData, TypeDefinition typeDefinition) { try { var classSignature = CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(typeDefinition); var cirClass = getCirClass(cirData, classSignature); // map attributes for this classs if (typeDefinition.CustomAttributes != null && typeDefinition.CustomAttributes.Count > 0) { foreach (CustomAttribute customAttribute in typeDefinition.CustomAttributes) { var constructorSignature = CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference(customAttribute.Constructor); var cirAttribute = new CirAttribute(constructorSignature); foreach (var constructorParameter in customAttribute.ConstructorParameters) { // var type = constructorParameter.GetType().FullName; cirAttribute.Parameters.Add(constructorParameter.ToString(), constructorParameter.GetType().FullName); } if (customAttribute.Fields.Count > 0 || customAttribute.Properties.Count > 0) { } cirClass.ClassAttributes.Add(cirAttribute); } } if (false == cirClass.HasBeenProcessedByCirFactory) { cirClass.HasBeenProcessedByCirFactory = true; cirClass.Name = typeDefinition.Name; cirClass.FullName = typeDefinition.FullName; cirClass.Module = typeDefinition.Module.Name; cirClass.Namespace = cirClass.Namespace; cirClass.SymbolDef = Guid.NewGuid().ToString(); cirClass.IsAbstract = typeDefinition.IsAbstract; // cirClass.IsAnonymous = typeDefinition. cirClass.IsClass = typeDefinition.IsClass; cirClass.IsEnum = typeDefinition.IsEnum; cirClass.IsInterface = typeDefinition.IsInterface; cirClass.IsImport = typeDefinition.IsImport; cirClass.IsNotPublic = typeDefinition.IsNotPublic; cirClass.IsPublic = typeDefinition.IsPublic; cirClass.HasSecurity = typeDefinition.HasSecurity; } else DI.log.info("This Class has already been processed, so only adding any possible extra methods: {0}", cirClass.Name); // handle constuctors foreach (MethodDefinition methodDefinition in typeDefinition.Constructors) { ICirFunction cirFunction = processMethodDefinition(cirData, methodDefinition, null); if (false == cirClass.dFunctions.ContainsValue(cirFunction)) cirClass.dFunctions.Add(cirFunction.FunctionSignature, cirFunction); // try to find source code reference if (cirFunction.FunctionsCalled.Count > 0 && cirClass.FileLine == null) if (false == string.IsNullOrEmpty(cirFunction.FunctionsCalled[0].fileName)) { cirClass.File = cirFunction.FunctionsCalled[0].fileName; cirClass.FileLine = "0"; // set it to zero and try to map it later } } // handle methods foreach (MethodDefinition methodDefinition in typeDefinition.Methods) { ICirFunction cirFunction = processMethodDefinition(cirData, methodDefinition, null); if (false == cirClass.dFunctions.ContainsValue(cirFunction)) cirClass.dFunctions.Add(cirFunction.FunctionSignature, cirFunction); } return cirClass; } catch (Exception ex) { DI.log.ex(ex, "in CirFactory.processTypeDefinition", true); return null; } }
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; } }