public static void calculateAllTracesFromFunction(String sSignature, TreeNodeCollection tncTraces, List<String> lFunctionsCalled, String sFilter_Signature, String sFilter_Parameter, bool bUseIsCalledBy, ICirDataAnalysis fcdAnalysis) { TreeNode tnNewTreeNode = O2Forms.newTreeNode(sSignature, sSignature, 0, sSignature); tncTraces.Add(tnNewTreeNode); if (fcdAnalysis.dCirFunction_bySignature.ContainsKey(sSignature)) { ICirFunction cfCirFunction = fcdAnalysis.dCirFunction_bySignature[sSignature]; List<ICirFunction> lsFunctions = new List<ICirFunction>(); if (bUseIsCalledBy) foreach(var cirFunctionCall in cfCirFunction.FunctionIsCalledBy) lsFunctions.Add(cirFunctionCall.cirFunction); else lsFunctions.AddRange(cfCirFunction.FunctionsCalledUniqueList); foreach (ICirFunction cirFunction in lsFunctions) if (false == lFunctionsCalled.Contains(cirFunction.FunctionSignature)) { lFunctionsCalled.Add(cirFunction.FunctionSignature); calculateAllTracesFromFunction(cirFunction.FunctionSignature, tnNewTreeNode.Nodes, lFunctionsCalled, sFilter_Signature, sFilter_Parameter, bUseIsCalledBy, fcdAnalysis); } else tnNewTreeNode.Nodes.Add("(Circular ref) : " + cirFunction.FunctionSignature); } }
public static ICirDataSearchResult executeSearch(ICirDataAnalysis cirDataAnalysis) { var fcdSearchResult = new CirDataSearchResult(cirDataAnalysis); CirSearch.executeSearch(fcdSearchResult); return(fcdSearchResult); }
public static KM_CirAction setCirDataAnalysis(ICirDataAnalysis cirDataAnalysis) { var kmCirAction = new KM_CirAction(); kmCirAction.CirDataAnalysis = cirDataAnalysis; kmCirAction.CirAction = IM_CirActions.setCirDataAnalysis; return kmCirAction; }
public void loadCirDataAnalysisObject(ICirDataAnalysis _cirDataAnalysis) { _cirDataAnalysis.onlyShowExternalFunctionsThatAreInvokedFromCFG = cirDataAnalysis.onlyShowExternalFunctionsThatAreInvokedFromCFG; _cirDataAnalysis.onlyShowFunctionsOrClassesWithControlFlowGraphs = cirDataAnalysis.onlyShowFunctionsOrClassesWithControlFlowGraphs; _cirDataAnalysis.onlyShowFunctionsWithCallersOrCallees = cirDataAnalysis.onlyShowFunctionsWithCallersOrCallees; cirDataAnalysis = _cirDataAnalysis; }
public void loadCirDataAnalysisObject(ICirDataAnalysis _cirDataAnalysis) { _cirDataAnalysis.onlyShowExternalFunctionsThatAreInvokedFromCFG = cirDataAnalysis.onlyShowExternalFunctionsThatAreInvokedFromCFG; _cirDataAnalysis.onlyShowFunctionsOrClassesWithControlFlowGraphs = cirDataAnalysis.onlyShowFunctionsOrClassesWithControlFlowGraphs; _cirDataAnalysis.onlyShowFunctionsWithCallersOrCallees = cirDataAnalysis.onlyShowFunctionsWithCallersOrCallees; cirDataAnalysis = _cirDataAnalysis; }
public static ICirData addO2CirDataFile(ICirDataAnalysis cirDataAnalysis, String sO2CirFileToAdd, bool useCachedVersionIfAvailable) { ICirData cirData; if (useCachedVersionIfAvailable && cirDataAnalysis.dCirDataFilesLoaded.ContainsKey(sO2CirFileToAdd)) { //DI.log.debug("O2CirData file already loaded: {0}", sO2CirFileToAdd); cirData = cirDataAnalysis.dCirDataFilesLoaded[sO2CirFileToAdd]; } else { // vars.set_(sO2CirFileToAdd, null); // force reload of the o2cirdata file //cirDataAnalysis.dCirDataFilesLoaded.Clear(); cirData = CirLoad.loadFile(sO2CirFileToAdd); if (cirData == null || cirData.dClasses_bySignature == null) // || cirData.lFiles.Count == 0) { return(null); } // add to main list if (cirDataAnalysis.dCirDataFilesLoaded.ContainsKey(sO2CirFileToAdd)) { cirDataAnalysis.dCirDataFilesLoaded[sO2CirFileToAdd] = cirData; } else { cirDataAnalysis.dCirDataFilesLoaded.Add(sO2CirFileToAdd, cirData); } } return(addO2CirDataFile(cirDataAnalysis, cirData)); }
public static void removeO2CirDataFile(ICirDataAnalysis cirDataAnalysis, String sO2CirDataFileToRemove) { if (cirDataAnalysis.dCirDataFilesLoaded.ContainsKey(sO2CirDataFileToRemove)) { ICirData fcdCirData = cirDataAnalysis.dCirDataFilesLoaded[sO2CirDataFileToRemove]; cirDataAnalysis.dCirDataFilesLoaded.Remove(sO2CirDataFileToRemove); foreach (ICirClass ccCirClass in fcdCirData.dClasses_bySignature.Values) { if (cirDataAnalysis.dCirClass.ContainsKey(ccCirClass)) { cirDataAnalysis.dCirClass.Remove(ccCirClass); cirDataAnalysis.dCirClass_bySignature.Remove(ccCirClass.Signature); foreach (ICirFunction cfCirFunction in ccCirClass.dFunctions.Values) { if (cirDataAnalysis.dCirFunction.ContainsKey(cfCirFunction)) { cirDataAnalysis.dCirFunction.Remove(cfCirFunction); cirDataAnalysis.dCirFunction_bySignature.Remove(cfCirFunction.FunctionSignature); } else { } } } else { } } showStatsOfLoadedData(cirDataAnalysis); } }
public static ICirFunction getFunctionRef(ICirDataAnalysis cirDataAnalysis, ICirFunction cirFunction) { if (false == cirDataAnalysis.dCirFunction_bySignature.ContainsKey(cirFunction.FunctionSignature)) { cirDataAnalysis.dCirFunction_bySignature.Add(cirFunction.FunctionSignature, cirFunction); } return(cirDataAnalysis.dCirFunction_bySignature[cirFunction.FunctionSignature]); }
public void setO2CirDataAnalysisObject(ICirDataAnalysis _cirDataAnalysis) { cirDataAnalysis = _cirDataAnalysis; asv_CalledFunctions.setO2CirDataAnalysisObject(cirDataAnalysis); asv_IsCalledBy.setO2CirDataAnalysisObject(cirDataAnalysis); afv_Calls.setNamespaceDepth(-1); afv_IsCalledBy.setNamespaceDepth(-1); }
public static KM_CirAction setCirDataAnalysis(ICirDataAnalysis cirDataAnalysis) { var kmCirAction = new KM_CirAction(); kmCirAction.CirDataAnalysis = cirDataAnalysis; kmCirAction.CirAction = IM_CirActions.setCirDataAnalysis; return(kmCirAction); }
public void setO2CirDataAnalysisObject(ICirDataAnalysis _cirDataAnalysis) { cirDataAnalysis = _cirDataAnalysis; asv_CalledFunctions.setO2CirDataAnalysisObject(cirDataAnalysis); asv_IsCalledBy.setO2CirDataAnalysisObject(cirDataAnalysis); afv_Calls.setNamespaceDepth(-1); afv_IsCalledBy.setNamespaceDepth(-1); }
private void onLoad() { if (runOnLoad && false == DesignMode) { PublicDI.o2MessageQueue.onMessages += o2MessageQueue_onMessages; cirDataAnalysis = new CirDataAnalysis(); runOnLoad = false; } }
private void onLoad() { if (runOnLoad && false == DesignMode) { PublicDI.o2MessageQueue.onMessages += o2MessageQueue_onMessages; cirDataAnalysis = new CirDataAnalysis(); runOnLoad = false; } }
public static KM_CirAction setCirDataAnalysis(ICirDataAnalysis cirDataAnalysis) { var kmCirAction = new KM_CirAction { CirAction = IM_CirActions.setCirDataAnalysis, CirDataAnalysis = cirDataAnalysis }; return kmCirAction; }
public static void openCirDataFileInCirViewerControl(ICirDataAnalysis cirDataAnalysis, string cirViewerControlName) { if (cirDataAnalysis != null) { var ascxCirViewer = (ascx_CirDataViewer)O2AscxGUI.getAscx(cirViewerControlName); if (ascxCirViewer != null) { ascxCirViewer.loadCirDataAnalysisObject(cirDataAnalysis); ascxCirViewer.updateCirDataStats(); } } }
private void deleteAllLoadedData() { // clean current results but keep the current viewing flags cirDataAnalysis = new CirDataAnalysis { onlyShowExternalFunctionsThatAreInvokedFromCFG = cirDataAnalysis.onlyShowExternalFunctionsThatAreInvokedFromCFG, onlyShowFunctionsOrClassesWithControlFlowGraphs = cirDataAnalysis.onlyShowFunctionsOrClassesWithControlFlowGraphs, onlyShowFunctionsWithCallersOrCallees = cirDataAnalysis.onlyShowFunctionsWithCallersOrCallees }; showLoadedFunctions(); updateCirDataStats(); }
// need to check of other class values public static void mergeClasses(ICirDataAnalysis cirDataAnalysis, ICirClass classHost, ICirClass classToMerge) { foreach (var propertyInfo in DI.reflection.getProperties(typeof(ICirClass))) { if (DI.reflection.getProperty(propertyInfo.Name, classHost) == null && DI.reflection.getProperty(propertyInfo.Name, classToMerge) != null) { DI.reflection.setProperty(propertyInfo.Name, classHost, DI.reflection.getProperty(propertyInfo.Name, classToMerge)); } } addClass(cirDataAnalysis, classToMerge); }
public static void openCirDataFileInCirViewerControl(ICirDataAnalysis cirDataAnalysis, string cirViewerControlName) { if (cirDataAnalysis != null) { var ascxCirViewer = (ascx_CirDataViewer) O2AscxGUI.getAscx(cirViewerControlName); if (ascxCirViewer != null) { ascxCirViewer.loadCirDataAnalysisObject(cirDataAnalysis); ascxCirViewer.updateCirDataStats(); } } }
public static void calculateXrefs_SuperClases_recursive(ICirDataAnalysis cirDataAnalysis, String sSuperClassCustomSignature, ICirClass ccClassToFollow) { sSuperClassCustomSignature = String.Format("{0}. <- {1}", sSuperClassCustomSignature, ccClassToFollow.Signature.Replace('.', '_')); if (false == cirDataAnalysis.lCirClass_bySuperClass.Contains(sSuperClassCustomSignature)) { cirDataAnalysis.lCirClass_bySuperClass.Add(sSuperClassCustomSignature); } foreach (CirClass ccIsSuperClassedBy in ccClassToFollow.dIsSuperClassedBy.Values) { calculateXrefs_SuperClases_recursive(cirDataAnalysis, sSuperClassCustomSignature, ccIsSuperClassedBy); } }
public static ICirData createCirDataFromCirDataAnalysis(ICirDataAnalysis cirDataAnalysis) { if (cirDataAnalysis == null) { return(null); } var cirData = new CirData { dClasses_bySignature = cirDataAnalysis.dCirClass_bySignature, dFunctions_bySignature = cirDataAnalysis.dCirFunction_bySignature, }; return(cirData); }
void o2MessageQueue_onMessages(IO2Message o2Message) { if (o2Message is IM_CirAction) { var cirAction = (IM_CirAction)o2Message; switch (cirAction.CirAction) { case IM_CirActions.setCirDataAnalysis: cirDataAnalysis = cirAction.CirDataAnalysis; LoadClassInfo(); break; } } }
public static void remapSuperClassesXrefs(ICirDataAnalysis cirDataAnalysis) { // first clear all xrefs foreach (ICirClass cirClass in cirDataAnalysis.dCirClass_bySignature.Values.ToList()) { cirClass.dIsSuperClassedBy = new Dictionary <string, ICirClass>(); } // now map the supperclases and IsSuperClassedBy foreach (ICirClass cirClass in cirDataAnalysis.dCirClass_bySignature.Values.ToList()) { foreach (string superClassSignature in cirClass.dSuperClasses.Keys.ToList()) { // make sure the dSuperClasses is mapped //if (cirClass.dSuperClasses[superClassSignature] == null) if (cirDataAnalysis.dCirClass_bySignature.ContainsKey(superClassSignature)) { if (cirClass.dSuperClasses[superClassSignature] == null) { cirClass.dSuperClasses[superClassSignature] = cirDataAnalysis.dCirClass_bySignature[superClassSignature]; } else { if (cirClass.dSuperClasses[superClassSignature] != cirDataAnalysis.dCirClass_bySignature[superClassSignature]) { } } } else { cirDataAnalysis.dCirClass_bySignature.Add(superClassSignature, new CirClass(superClassSignature)); cirClass.dSuperClasses[superClassSignature] = cirDataAnalysis.dCirClass_bySignature[superClassSignature]; } // now map dIsSuperClassedBy cirDataAnalysis.dCirClass_bySignature[superClassSignature].dIsSuperClassedBy.Add(cirClass.Signature, cirClass); } } /*foreach (ICirClass cirClass in cirDataAnalysis.dCirClass_bySignature.Values.ToList()) * foreach (string superClassSignature in cirClass.dSuperClasses.Keys.ToList()) * if (cirClass.dSuperClasses[superClassSignature] == null) * if (cirDataAnalysis.dCirClass_bySignature.ContainsKey(superClassSignature)) * cirClass.dSuperClasses[superClassSignature] = cirDataAnalysis.dCirClass_bySignature[superClassSignature]; * else * { * cirDataAnalysis.dCirClass_bySignature.Add(superClassSignature, new CirClass(superClassSignature)); * cirClass.dSuperClasses[superClassSignature] = cirDataAnalysis.dCirClass_bySignature[superClassSignature]; * }*/ }
public static string createO2AssessmentWithCallFlowTraces(ICirDataAnalysis cirDataAnalysis) { DI.log.info("Creating O2Assessment With Call Flow Traces"); var timer = new O2Timer("Created list of finding").start(); var cirFunctionsToProcess = cirDataAnalysis.dCirFunction_bySignature.Values; var o2Findings = createO2FindingsFromCirFunctions(cirFunctionsToProcess); timer.stop(); timer = new O2Timer("Saved Assessment").start(); var o2Assessment = new O2Assessment(); o2Assessment.o2Findings = o2Findings; var savedFile = o2Assessment.save(new O2AssessmentSave_OunceV6()); DI.log.info("Saved O2Asssessment file created: {0}", savedFile); timer.stop(); return savedFile; }
public static string createO2AssessmentWithCallFlowTraces(ICirDataAnalysis cirDataAnalysis) { DI.log.info("Creating O2Assessment With Call Flow Traces"); var timer = new O2Timer("Created list of finding").start(); var cirFunctionsToProcess = cirDataAnalysis.dCirFunction_bySignature.Values; var o2Findings = createO2FindingsFromCirFunctions(cirFunctionsToProcess); timer.stop(); timer = new O2Timer("Saved Assessment").start(); var o2Assessment = new O2Assessment(); o2Assessment.o2Findings = o2Findings; var savedFile = o2Assessment.save(new O2AssessmentSave_OunceV6()); DI.log.info("Saved O2Asssessment file created: {0}", savedFile); timer.stop(); return(savedFile); }
public static void remapXrefs(ICirDataAnalysis cirDataAnalysis) { DI.log.debug("Remapping Methods and Classes XReferences"); var timer = new O2Timer("Remapping XRefs took: {0}").start(); remapIsCalledByXrefs(cirDataAnalysis); // make sure everythings is pointing to the correct place calculateXrefs_SuperClases(cirDataAnalysis); // ensure all the methods are mapped to the correct class foreach (var cirClass in cirDataAnalysis.dCirClass_bySignature.Values) { foreach (var cirFunction in cirClass.dFunctions.Values) { cirFunction.ParentClass = cirClass; cirFunction.ParentClassFullName = cirClass.FullName; cirFunction.ParentClassName = cirClass.Name; } } timer.stop(); }
private static void addClass(ICirDataAnalysis cirDataAnalysis, ICirClass ccCirClass) { if (cirDataAnalysis.dCirClass_bySignature.ContainsKey(ccCirClass.Signature)) { var mainRefCirClass = cirDataAnalysis.dCirClass_bySignature[ccCirClass.Signature]; if (mainRefCirClass != ccCirClass) // if they are diferent we need to sync the superclasses dictionary { foreach (var superclass in ccCirClass.dSuperClasses.Keys) { if (false == mainRefCirClass.dSuperClasses.ContainsKey(superclass)) { mainRefCirClass.dSuperClasses.Add(superclass, ccCirClass.dSuperClasses[superclass]); } } } } else { } foreach (ICirFunction cfCirFunction in ccCirClass.dFunctions.Values) // if (cfCirFunction.HasControlFlowGraph) { if (false == cirDataAnalysis.dCirFunction.ContainsKey(cfCirFunction)) { cirDataAnalysis.dCirFunction.Add(cfCirFunction, ccCirClass); } // we need this cross check with ccCirClass since we will it to resolve cfCirFunction data if (false == cirDataAnalysis.dCirFunction_bySignature.ContainsKey(cfCirFunction.FunctionSignature)) { addFunction(cirDataAnalysis, cfCirFunction); } else { var functionHost = cirDataAnalysis.dCirFunction_bySignature[cfCirFunction.FunctionSignature]; var functionToMerge = cfCirFunction; mergeFunctions(cirDataAnalysis, functionHost, functionToMerge); } } }
public static void calculateAllTracesFromFunction(String sSignature, TreeNodeCollection tncTraces, List <String> lFunctionsCalled, String sFilter_Signature, String sFilter_Parameter, bool bUseIsCalledBy, ICirDataAnalysis fcdAnalysis) { TreeNode tnNewTreeNode = O2Forms.newTreeNode(sSignature, sSignature, 0, sSignature); tncTraces.Add(tnNewTreeNode); if (fcdAnalysis.dCirFunction_bySignature.ContainsKey(sSignature)) { ICirFunction cfCirFunction = fcdAnalysis.dCirFunction_bySignature[sSignature]; List <ICirFunction> lsFunctions = new List <ICirFunction>(); if (bUseIsCalledBy) { foreach (var cirFunctionCall in cfCirFunction.FunctionIsCalledBy) { lsFunctions.Add(cirFunctionCall.cirFunction); } } else { lsFunctions.AddRange(cfCirFunction.FunctionsCalledUniqueList); } foreach (ICirFunction cirFunction in lsFunctions) { if (false == lFunctionsCalled.Contains(cirFunction.FunctionSignature)) { lFunctionsCalled.Add(cirFunction.FunctionSignature); calculateAllTracesFromFunction(cirFunction.FunctionSignature, tnNewTreeNode.Nodes, lFunctionsCalled, sFilter_Signature, sFilter_Parameter, bUseIsCalledBy, fcdAnalysis); } else { tnNewTreeNode.Nodes.Add("(Circular ref) : " + cirFunction.FunctionSignature); } } } }
private static ICirFunction syncFunctions(ICirDataAnalysis cirDataAnalysis, ICirFunction cirFunctionToSync) { try { var functionRef = getFunctionRef(cirDataAnalysis, cirFunctionToSync); //var functionCalled = cirFunction.FunctionsCalledSequence[i]; if (cirFunctionToSync.GetHashCode() != functionRef.GetHashCode()) { mergeFunctions(cirDataAnalysis, functionRef, cirFunctionToSync); } //cirFunction.FunctionsCalledSequence[i] = functionRef; return(functionRef); } catch (Exception ex) { DI.log.error("in CirDataAnalysisUtils.syncFunctions, for function {1} : {1}", cirFunctionToSync.FunctionSignature, ex.Message); } return(cirFunctionToSync); }
public static ICirData addO2CirDataFile(ICirDataAnalysis cirDataAnalysis, String sO2CirFileToAdd, bool useCachedVersionIfAvailable) { ICirData cirData; if (useCachedVersionIfAvailable && cirDataAnalysis.dCirDataFilesLoaded.ContainsKey(sO2CirFileToAdd)) { //DI.log.debug("O2CirData file already loaded: {0}", sO2CirFileToAdd); cirData = cirDataAnalysis.dCirDataFilesLoaded[sO2CirFileToAdd]; } else { // vars.set_(sO2CirFileToAdd, null); // force reload of the o2cirdata file //cirDataAnalysis.dCirDataFilesLoaded.Clear(); cirData = CirLoad.loadFile(sO2CirFileToAdd); if (cirData == null || cirData.dClasses_bySignature == null) // || cirData.lFiles.Count == 0) return null; // add to main list if (cirDataAnalysis.dCirDataFilesLoaded.ContainsKey(sO2CirFileToAdd)) cirDataAnalysis.dCirDataFilesLoaded[sO2CirFileToAdd] = cirData; else cirDataAnalysis.dCirDataFilesLoaded.Add(sO2CirFileToAdd, cirData); } return addO2CirDataFile(cirDataAnalysis, cirData); }
private void clearLoadedData() { cirDataAnalysis = new CirDataAnalysis(); raiseSetCirDataAnalysisO2Message(); }
public static ICirFunction getFunctionRef(ICirDataAnalysis cirDataAnalysis, ICirFunction cirFunction) { if (false == cirDataAnalysis.dCirFunction_bySignature.ContainsKey(cirFunction.FunctionSignature)) cirDataAnalysis.dCirFunction_bySignature.Add(cirFunction.FunctionSignature, cirFunction); return cirDataAnalysis.dCirFunction_bySignature[cirFunction.FunctionSignature]; }
public static void loadFileIntoCirDataAnalysisObject(string sFileToLoad, ICirDataAnalysis cirDataAnalysis, bool decompileCodeIfNoPdb) { loadFileIntoCirDataAnalysisObject(sFileToLoad, cirDataAnalysis, true, true /*useCachedVersionIfAvailable*/ , true /*runRemapXrefs*/, decompileCodeIfNoPdb); }
public static void saveCirDataAnalysisObjectAsCirDataFile(ICirDataAnalysis cirDataAnalysis, string savedCirDataFile) { var cirData = createCirDataFromCirDataAnalysis(cirDataAnalysis); CirDataUtils.saveSerializedO2CirDataObjectToFile(cirData, savedCirDataFile); }
public static void removeO2CirDataFile(ICirDataAnalysis cirDataAnalysis, String sO2CirDataFileToRemove) { if (cirDataAnalysis.dCirDataFilesLoaded.ContainsKey(sO2CirDataFileToRemove)) { ICirData fcdCirData = cirDataAnalysis.dCirDataFilesLoaded[sO2CirDataFileToRemove]; cirDataAnalysis.dCirDataFilesLoaded.Remove(sO2CirDataFileToRemove); foreach (ICirClass ccCirClass in fcdCirData.dClasses_bySignature.Values) if (cirDataAnalysis.dCirClass.ContainsKey(ccCirClass)) { cirDataAnalysis.dCirClass.Remove(ccCirClass); cirDataAnalysis.dCirClass_bySignature.Remove(ccCirClass.Signature); foreach (ICirFunction cfCirFunction in ccCirClass.dFunctions.Values) if (cirDataAnalysis.dCirFunction.ContainsKey(cfCirFunction)) { cirDataAnalysis.dCirFunction.Remove(cfCirFunction); cirDataAnalysis.dCirFunction_bySignature.Remove(cfCirFunction.FunctionSignature); } else { } } else { } showStatsOfLoadedData(cirDataAnalysis); } }
public static ICirDataSearchResult executeSearch(ICirDataAnalysis cirDataAnalysis) { var fcdSearchResult = new CirDataSearchResult(cirDataAnalysis); CirSearch.executeSearch(fcdSearchResult); return fcdSearchResult; }
public static ICirData addO2CirDataFile(ICirDataAnalysis cirDataAnalysis, ICirData cirData) { return addO2CirDataFile(cirDataAnalysis, cirData, true /* runRemapXrefs */); }
public static ICirData addO2CirDataFile(ICirDataAnalysis cirDataAnalysis, ICirData cirData, bool runRemapXrefs) { if (cirData == null) return null; // check for sDbId (will be needed to get data from Ounce Db if (!String.IsNullOrEmpty(cirDataAnalysis.sDb_Id) && cirDataAnalysis.sDb_Id != cirData.sDbId) DI.log.error( "The O2CirData files have different Db_Ids, The rules creation will use the last one loaded:{0}", cirData.sDbId); if (String.IsNullOrEmpty(cirDataAnalysis.sDb_Id)) cirDataAnalysis.sDb_Id = cirData.sDbId; // add classes with ControlFlowGraphs to list of classes to process var sClasses = new List<string>(cirData.dClasses_bySignature.Keys); sClasses.Sort(); //cirDataAnalysis.dCirClass.Clear(); foreach (ICirClass ccCirClass in cirData.dClasses_bySignature.Values) { //if (ccCirClass.bClassHasMethodsWithControlFlowGraphs && false == cirDataAnalysis.dCirClass.ContainsKey(ccCirClass)) try { // if (false == cirDataAnalysis.dCirClass.ContainsKey(ccCirClass)) // cirDataAnalysis.dCirClass.Add(ccCirClass, cirData); if (false == cirDataAnalysis.dCirClass_bySignature.ContainsKey(ccCirClass.Signature)) { cirDataAnalysis.dCirClass_bySignature.Add(ccCirClass.Signature, ccCirClass); addClass(cirDataAnalysis, ccCirClass); if (false == cirDataAnalysis.dCirClass.ContainsKey(ccCirClass)) cirDataAnalysis.dCirClass.Add(ccCirClass, cirData); } else { var classHost = cirDataAnalysis.dCirClass_bySignature[ccCirClass.Signature]; var classToMerge = ccCirClass; mergeClasses(cirDataAnalysis, classHost, classToMerge); } } catch (Exception ex) { DI.log.debug("in addO2CirDataFile : {0}", ex.Message); //DC: to-do: debug the cases where this exception is triggered } } /* var methodtofind = "System.Data!System.Int32 System.Data.IDataRecord::GetOrdinal(System.String)"; if (cirData.dFunctions_bySignature.ContainsKey(methodtofind)) { } if (cirDataAnalysis.dCirFunction_bySignature.ContainsKey(methodtofind)) { }*/ //if (true) if (runRemapXrefs) { remapXrefs(cirDataAnalysis); showStatsOfLoadedData(cirDataAnalysis); } else // if we are not remapping the XRefs then remove any FunctionIsCalledBy that are there (since some might be wrong) { foreach (var cirFunction in cirData.dFunctions_bySignature.Values) cirFunction.FunctionIsCalledBy = new List<ICirFunctionCall>(); } return cirData; }
private static void addFunction(ICirDataAnalysis cirDataAnalysis, ICirFunction cirFunction) { cirDataAnalysis.dCirFunction_bySignature.Add(cirFunction.FunctionSignature, cirFunction); }
public static void remapSuperClassesXrefs(ICirDataAnalysis cirDataAnalysis) { // first clear all xrefs foreach (ICirClass cirClass in cirDataAnalysis.dCirClass_bySignature.Values.ToList()) { cirClass.dIsSuperClassedBy = new Dictionary<string, ICirClass>(); } // now map the supperclases and IsSuperClassedBy foreach (ICirClass cirClass in cirDataAnalysis.dCirClass_bySignature.Values.ToList()) { foreach (string superClassSignature in cirClass.dSuperClasses.Keys.ToList()) { // make sure the dSuperClasses is mapped //if (cirClass.dSuperClasses[superClassSignature] == null) if (cirDataAnalysis.dCirClass_bySignature.ContainsKey(superClassSignature)) if (cirClass.dSuperClasses[superClassSignature] == null) cirClass.dSuperClasses[superClassSignature] = cirDataAnalysis.dCirClass_bySignature[superClassSignature]; else { if (cirClass.dSuperClasses[superClassSignature] != cirDataAnalysis.dCirClass_bySignature[superClassSignature]) { } } else { cirDataAnalysis.dCirClass_bySignature.Add(superClassSignature, new CirClass(superClassSignature)); cirClass.dSuperClasses[superClassSignature] = cirDataAnalysis.dCirClass_bySignature[superClassSignature]; } // now map dIsSuperClassedBy cirDataAnalysis.dCirClass_bySignature[superClassSignature].dIsSuperClassedBy.Add(cirClass.Signature, cirClass); } } /*foreach (ICirClass cirClass in cirDataAnalysis.dCirClass_bySignature.Values.ToList()) foreach (string superClassSignature in cirClass.dSuperClasses.Keys.ToList()) if (cirClass.dSuperClasses[superClassSignature] == null) if (cirDataAnalysis.dCirClass_bySignature.ContainsKey(superClassSignature)) cirClass.dSuperClasses[superClassSignature] = cirDataAnalysis.dCirClass_bySignature[superClassSignature]; else { cirDataAnalysis.dCirClass_bySignature.Add(superClassSignature, new CirClass(superClassSignature)); cirClass.dSuperClasses[superClassSignature] = cirDataAnalysis.dCirClass_bySignature[superClassSignature]; }*/ }
public static void showStatsOfLoadedData(ICirDataAnalysis cirDataAnalysis) { DI.log.debug("There are {0} CirData files loaded with {1} classes and {2} functions", cirDataAnalysis.dCirDataFilesLoaded.Count, cirDataAnalysis.dCirClass.Count, cirDataAnalysis.dCirFunction.Count); }
public static void loadFileIntoCirDataAnalysisObject(string sFileToLoad, ICirDataAnalysis cirDataAnalysis) { loadFileIntoCirDataAnalysisObject(sFileToLoad, cirDataAnalysis, false /*decompileCodeIfNoPdb*/); }
public static void saveCirDataAnalysisObjectAsCirDataFile(ICirDataAnalysis cirDataAnalysis, string savedCirDataFile) { var cirData = createCirDataFromCirDataAnalysis(cirDataAnalysis); CirDataUtils.saveSerializedO2CirDataObjectToFile(cirData, savedCirDataFile); }
public static void loadFileIntoCirDataAnalysisObject(string sFileToLoad, ICirDataAnalysis cirDataAnalysis, bool showNotSupportedExtensionError, bool useCachedVersionIfAvailable, bool runRemapXrefs, bool decompileCodeIfNoPdb) { try { switch (Path.GetExtension(sFileToLoad).ToLower()) { case ".cirdata": addO2CirDataFile(cirDataAnalysis, sFileToLoad, useCachedVersionIfAvailable); break; case ".dll": case ".exe": if (CecilUtils.isDotNetAssembly(sFileToLoad, false)) { ICirData assemblyCirData = new CirData(); new CirFactory().processAssemblyDefinition(assemblyCirData, CecilUtils.getAssembly(sFileToLoad), sFileToLoad, decompileCodeIfNoPdb); if (assemblyCirData.dClasses_bySignature.Count == 0) { DI.log.error("There were no classes imporeted from the file: {0}", sFileToLoad); } else { var fileName = Path.GetFileName(sFileToLoad); if (false == cirDataAnalysis.dCirDataFilesLoaded.ContainsKey(fileName)) { cirDataAnalysis.dCirDataFilesLoaded.Add(Path.GetFileName(sFileToLoad), assemblyCirData); } addO2CirDataFile(cirDataAnalysis, assemblyCirData, runRemapXrefs); } } else { DI.log.error("Droped *.exe or *.dll file was not a .Net assembly: {0}", sFileToLoad); } break; case "*.xml": if (CirLoad.isFileACirDumpFile(sFileToLoad)) { addO2CirDataFile(cirDataAnalysis, sFileToLoad, useCachedVersionIfAvailable); } break; default: if (showNotSupportedExtensionError) { DI.log.error( "Could not process file dropped (it it not a CirData file or a .NET assembly: {0}", sFileToLoad); } break; } } catch (Exception ex) { DI.log.error( "in loadFileIntoCirDataAnalysisObject, error {0} while loading {1} : ", sFileToLoad, ex.Message); } }
public static void loadFileIntoCirDataAnalysisObject(string sFileToLoad, ICirDataAnalysis cirDataAnalysis, bool decompileCodeIfNoPdb) { loadFileIntoCirDataAnalysisObject(sFileToLoad, cirDataAnalysis, true, true /*useCachedVersionIfAvailable*/, true /*runRemapXrefs*/, decompileCodeIfNoPdb); }
public static void calculateXrefs_SuperClases(ICirDataAnalysis cirDataAnalysis) { try { // first make sure the super classes are pointing to null /* foreach (ICirClass cirClass in cirDataAnalysis.dCirClass_bySignature.Values.ToList()) foreach (string superClassSignature in cirClass.dSuperClasses.Keys.ToList()) if (cirClass.dSuperClasses[superClassSignature] == null) if (cirDataAnalysis.dCirClass_bySignature.ContainsKey(superClassSignature)) cirClass.dSuperClasses[superClassSignature] = cirDataAnalysis.dCirClass_bySignature[superClassSignature]; else { cirDataAnalysis.dCirClass_bySignature.Add(superClassSignature,new CirClass(superClassSignature)); cirClass.dSuperClasses[superClassSignature] = cirDataAnalysis.dCirClass_bySignature[superClassSignature]; }*/ bool ignoreJavaLangObjectCount = true; int iIgnoredJavaLangObjectCount = 0; foreach (ICirClass ccCirClass in cirDataAnalysis.dCirClass_bySignature.Values) foreach (ICirClass ccSuperClass in ccCirClass.dSuperClasses.Values) { if (ignoreJavaLangObjectCount && (ccSuperClass.Signature == "java.lang.Object" || ccSuperClass.Signature == "System.Object")) iIgnoredJavaLangObjectCount++; else { calculateXrefs_SuperClases_recursive(cirDataAnalysis, ccSuperClass.Signature, ccCirClass); //dCirClass_bySuperClass_Simple[sSuperClassCustomSignature].Add(ccCirClass); // foreach (CirClass ccIsSuperClassedBy in ccSuperClass.dIsSuperClassedBy.Values) // { // String sIsSuperClassedByCustomSignature = String.Format("{0}.<-.{1}", sSuperClassCustomSignature, ccIsSuperClassedBy.FunctionSignature.Replace('.', '_')); // dCirClass_bySuperClass_Simple.Add(sIsSuperClassedByCustomSignature, null); // } } /* if (false == dCirClass_bySuperClass_Recursive.ContainsKey(ccSuperClass.FunctionSignature)) dCirClass_bySuperClass_Recursive.Add(ccSuperClass.FunctionSignature, new List<CirClass>()); dCirClass_bySuperClass_Recursive[ccSuperClass.FunctionSignature].Add(ccCirClass); */ // calculateXrefs_SuperClases_recursive(sSuperClass); } if (iIgnoredJavaLangObjectCount > 0) DI.log.debug("# of Ignored java.lang.Object:{0}", iIgnoredJavaLangObjectCount); if (cirDataAnalysis.lCirClass_bySuperClass.Count > 0) DI.log.debug("# of SuperClass mappings:{0}", cirDataAnalysis.lCirClass_bySuperClass.Count); } catch (Exception ex) { DI.log.error("in calculateXrefs_SuperClases:{0}", ex.Message); } }
public static ICirData addO2CirDataFile(ICirDataAnalysis cirDataAnalysis, ICirData cirData, bool runRemapXrefs) { if (cirData == null) { return(null); } // check for sDbId (will be needed to get data from Ounce Db if (!String.IsNullOrEmpty(cirDataAnalysis.sDb_Id) && cirDataAnalysis.sDb_Id != cirData.sDbId) { DI.log.error( "The O2CirData files have different Db_Ids, The rules creation will use the last one loaded:{0}", cirData.sDbId); } if (String.IsNullOrEmpty(cirDataAnalysis.sDb_Id)) { cirDataAnalysis.sDb_Id = cirData.sDbId; } // add classes with ControlFlowGraphs to list of classes to process var sClasses = new List <string>(cirData.dClasses_bySignature.Keys); sClasses.Sort(); //cirDataAnalysis.dCirClass.Clear(); foreach (ICirClass ccCirClass in cirData.dClasses_bySignature.Values) { //if (ccCirClass.bClassHasMethodsWithControlFlowGraphs && false == cirDataAnalysis.dCirClass.ContainsKey(ccCirClass)) try { // if (false == cirDataAnalysis.dCirClass.ContainsKey(ccCirClass)) // cirDataAnalysis.dCirClass.Add(ccCirClass, cirData); if (false == cirDataAnalysis.dCirClass_bySignature.ContainsKey(ccCirClass.Signature)) { cirDataAnalysis.dCirClass_bySignature.Add(ccCirClass.Signature, ccCirClass); addClass(cirDataAnalysis, ccCirClass); if (false == cirDataAnalysis.dCirClass.ContainsKey(ccCirClass)) { cirDataAnalysis.dCirClass.Add(ccCirClass, cirData); } } else { var classHost = cirDataAnalysis.dCirClass_bySignature[ccCirClass.Signature]; var classToMerge = ccCirClass; mergeClasses(cirDataAnalysis, classHost, classToMerge); } } catch (Exception ex) { DI.log.debug("in addO2CirDataFile : {0}", ex.Message); //DC: to-do: debug the cases where this exception is triggered } } /* var methodtofind = "System.Data!System.Int32 System.Data.IDataRecord::GetOrdinal(System.String)"; * if (cirData.dFunctions_bySignature.ContainsKey(methodtofind)) * { * } * if (cirDataAnalysis.dCirFunction_bySignature.ContainsKey(methodtofind)) * { * }*/ //if (true) if (runRemapXrefs) { remapXrefs(cirDataAnalysis); showStatsOfLoadedData(cirDataAnalysis); } else // if we are not remapping the XRefs then remove any FunctionIsCalledBy that are there (since some might be wrong) { foreach (var cirFunction in cirData.dFunctions_bySignature.Values) { cirFunction.FunctionIsCalledBy = new List <ICirFunctionCall>(); } } return(cirData); }
public static void remapIsCalledByXrefs(ICirDataAnalysis cirDataAnalysis) { try { remapSuperClassesXrefs(cirDataAnalysis); var timer = new O2Timer("remapIsCalledByXrefs").start(); // first clear all Xref foreach (var cirFunction in cirDataAnalysis.dCirFunction_bySignature.Values) cirFunction.FunctionIsCalledBy = new List<ICirFunctionCall>(); // make sure all FunctionsCalledUniqueList and FunctionsCalled are syncronized with dCirFunction_bySignature var functionsToMap = cirDataAnalysis.dCirFunction_bySignature.Values.ToList().Count; var functionsProcessed = 0; foreach (var cirFunction in cirDataAnalysis.dCirFunction_bySignature.Values.ToList()) { for (int i = 0; i < cirFunction.FunctionsCalledUniqueList.Count; i++) cirFunction.FunctionsCalledUniqueList[i] = syncFunctions(cirDataAnalysis, cirFunction.FunctionsCalledUniqueList[i]); for (int i = 0; i < cirFunction.FunctionsCalled.Count; i++) cirFunction.FunctionsCalled[i].cirFunction = syncFunctions(cirDataAnalysis, cirFunction.FunctionsCalled[i].cirFunction); if ((functionsProcessed++) % 500 == 0) DI.log.info(" processed {0} / {1}", functionsProcessed, functionsToMap); } // check the FunctionsCalledUniqueList is calledby mappngs foreach (var cirFunction in cirDataAnalysis.dCirFunction_bySignature.Values) foreach (var functionCalled in cirFunction.FunctionsCalled) { var functionCalledXref = getFunctionRef(cirDataAnalysis, functionCalled.cirFunction); /*if (false == cirDataAnalysis.dCirFunction_bySignature.ContainsValue(functionCalled)) DI.log.error("in remapIsCalledByXrefs something is wrong because the called fucntions does not have a cirFunction mapping: {0}", functionCalled.FunctionSignature); else //{*/ bool found = false; foreach (var functionCall in functionCalled.cirFunction.FunctionIsCalledBy) if (functionCall.cirFunction == functionCalledXref) found = true; if (found == false) functionCalled.cirFunction.FunctionIsCalledBy.Add(new CirFunctionCall(cirFunction, functionCalled.fileName, functionCalled.lineNumber)); //if (false == functionCalledXref.FunctionIsCalledBy.Contains(cirFunction)) // functionCalledXref.FunctionIsCalledBy.Add(cirFunction); } // make sure all functions are syncronized with dCirFunction_bySignature foreach (var cirFunction in cirDataAnalysis.dCirFunction_bySignature.Values) for (int i = 0; i < cirFunction.FunctionsCalledUniqueList.Count; i++) cirFunction.FunctionsCalledUniqueList[i] = syncFunctions(cirDataAnalysis, cirFunction.FunctionsCalledUniqueList[i]); // endure all iscalledby are correcly mapped foreach (var cirFunction in cirDataAnalysis.dCirFunction_bySignature.Values) for (int i = 0; i < cirFunction.FunctionIsCalledBy.Count; i++) cirFunction.FunctionIsCalledBy[i].cirFunction = syncFunctions(cirDataAnalysis, cirFunction.FunctionIsCalledBy[i].cirFunction); // make sure there is a reference to this function on the Classes Dictionanry foreach (var cirFunction in cirDataAnalysis.dCirFunction_bySignature.Values) foreach (var functionCalled in cirFunction.FunctionsCalled) if (functionCalled.cirFunction.ParentClass == null) { var functionSignature = new FilteredSignature(functionCalled.cirFunction.FunctionSignature); var parentClassName = functionSignature.sFunctionClass; if (false == cirDataAnalysis.dCirClass_bySignature.ContainsKey(parentClassName)) cirDataAnalysis.dCirClass_bySignature.Add(parentClassName, new CirClass(parentClassName)); var parentCirClass = cirDataAnalysis.dCirClass_bySignature[parentClassName]; var functionAlreadyMappedToClass = false; foreach (var cirFunctionMappedToClass in parentCirClass.dFunctions.Values) if (cirFunctionMappedToClass.FunctionSignature == functionCalled.cirFunction.FunctionSignature) functionAlreadyMappedToClass = true; if (false == functionAlreadyMappedToClass) parentCirClass.dFunctions.Add(functionCalled.cirFunction.FunctionSignature, functionCalled.cirFunction); functionCalled.cirFunction.ParentClass = parentCirClass; functionCalled.cirFunction.ParentClassName = parentCirClass.Name; functionCalled.cirFunction.ParentClassFullName = parentCirClass.FullName; } timer.stop(); } catch (Exception ex) { DI.log.error("in remapIsCalledByXrefs: {0}", ex.Message); } }
public static Thread setCirDataAnalysis(ICirDataAnalysis cirDataAnalysis) { return(DI.o2MessageQueue.sendMessage(KM_CirAction.setCirDataAnalysis(cirDataAnalysis))); }
private static ICirFunction syncFunctions(ICirDataAnalysis cirDataAnalysis, ICirFunction cirFunctionToSync) { try { var functionRef = getFunctionRef(cirDataAnalysis, cirFunctionToSync); //var functionCalled = cirFunction.FunctionsCalledSequence[i]; if (cirFunctionToSync.GetHashCode() != functionRef.GetHashCode()) mergeFunctions(cirDataAnalysis, functionRef, cirFunctionToSync); //cirFunction.FunctionsCalledSequence[i] = functionRef; return functionRef; } catch (Exception ex) { DI.log.error("in CirDataAnalysisUtils.syncFunctions, for function {1} : {1}", cirFunctionToSync.FunctionSignature, ex.Message); } return cirFunctionToSync; }
public void setO2CirDataAnalysisObject(ICirDataAnalysis _cirDataAnalysis) { cirDataAnalysis = _cirDataAnalysis; }
public static void calculateXrefs_SuperClases_recursive(ICirDataAnalysis cirDataAnalysis, String sSuperClassCustomSignature, ICirClass ccClassToFollow) { sSuperClassCustomSignature = String.Format("{0}. <- {1}", sSuperClassCustomSignature, ccClassToFollow.Signature.Replace('.', '_')); if (false == cirDataAnalysis.lCirClass_bySuperClass.Contains(sSuperClassCustomSignature)) cirDataAnalysis.lCirClass_bySuperClass.Add(sSuperClassCustomSignature); foreach (CirClass ccIsSuperClassedBy in ccClassToFollow.dIsSuperClassedBy.Values) calculateXrefs_SuperClases_recursive(cirDataAnalysis, sSuperClassCustomSignature, ccIsSuperClassedBy); }
public static void remapXrefs(ICirDataAnalysis cirDataAnalysis) { DI.log.debug("Remapping Methods and Classes XReferences"); var timer = new O2Timer("Remapping XRefs took: {0}").start(); remapIsCalledByXrefs(cirDataAnalysis); // make sure everythings is pointing to the correct place calculateXrefs_SuperClases(cirDataAnalysis); // ensure all the methods are mapped to the correct class foreach(var cirClass in cirDataAnalysis.dCirClass_bySignature.Values) foreach(var cirFunction in cirClass.dFunctions.Values) { cirFunction.ParentClass = cirClass; cirFunction.ParentClassFullName = cirClass.FullName; cirFunction.ParentClassName = cirClass.Name; } timer.stop(); }
public static void showStatsOfLoadedData(ICirDataAnalysis cirDataAnalysis) { DI.log.debug("There are {0} CirData files loaded with {1} classes and {2} functions", cirDataAnalysis.dCirDataFilesLoaded.Count, cirDataAnalysis.dCirClass.Count, cirDataAnalysis.dCirFunction.Count); }
private static void addClass(ICirDataAnalysis cirDataAnalysis, ICirClass ccCirClass) { if (cirDataAnalysis.dCirClass_bySignature.ContainsKey(ccCirClass.Signature)) { var mainRefCirClass = cirDataAnalysis.dCirClass_bySignature[ccCirClass.Signature]; if (mainRefCirClass != ccCirClass) // if they are diferent we need to sync the superclasses dictionary { foreach (var superclass in ccCirClass.dSuperClasses.Keys) if (false == mainRefCirClass.dSuperClasses.ContainsKey(superclass)) mainRefCirClass.dSuperClasses.Add(superclass, ccCirClass.dSuperClasses[superclass]); } } else { } foreach (ICirFunction cfCirFunction in ccCirClass.dFunctions.Values) // if (cfCirFunction.HasControlFlowGraph) { if (false == cirDataAnalysis.dCirFunction.ContainsKey(cfCirFunction)) cirDataAnalysis.dCirFunction.Add(cfCirFunction, ccCirClass); // we need this cross check with ccCirClass since we will it to resolve cfCirFunction data if (false == cirDataAnalysis.dCirFunction_bySignature.ContainsKey(cfCirFunction.FunctionSignature)) addFunction(cirDataAnalysis, cfCirFunction); else { var functionHost = cirDataAnalysis.dCirFunction_bySignature[cfCirFunction.FunctionSignature]; var functionToMerge = cfCirFunction; mergeFunctions(cirDataAnalysis, functionHost, functionToMerge); } } }
public static void loadFileIntoCirDataAnalysisObject(string sFileToLoad, ICirDataAnalysis cirDataAnalysis) { loadFileIntoCirDataAnalysisObject(sFileToLoad, cirDataAnalysis, false /*decompileCodeIfNoPdb*/); }
// need to check of other class values public static void mergeClasses(ICirDataAnalysis cirDataAnalysis, ICirClass classHost, ICirClass classToMerge) { foreach (var propertyInfo in DI.reflection.getProperties(typeof(ICirClass))) if (DI.reflection.getProperty(propertyInfo.Name, classHost) == null && DI.reflection.getProperty(propertyInfo.Name, classToMerge) != null) DI.reflection.setProperty(propertyInfo.Name, classHost, DI.reflection.getProperty(propertyInfo.Name, classToMerge)); addClass(cirDataAnalysis, classToMerge); }
public static void loadFileIntoCirDataAnalysisObject(string sFileToLoad, ICirDataAnalysis cirDataAnalysis, bool showNotSupportedExtensionError, bool useCachedVersionIfAvailable, bool runRemapXrefs, bool decompileCodeIfNoPdb) { try { switch (Path.GetExtension(sFileToLoad).ToLower()) { case ".cirdata": addO2CirDataFile(cirDataAnalysis, sFileToLoad, useCachedVersionIfAvailable); break; case ".dll": case ".exe": if (CecilUtils.isDotNetAssembly(sFileToLoad, false)) { ICirData assemblyCirData = new CirData(); new CirFactory().processAssemblyDefinition(assemblyCirData, CecilUtils.getAssembly(sFileToLoad), sFileToLoad, decompileCodeIfNoPdb); if (assemblyCirData.dClasses_bySignature.Count == 0) DI.log.error("There were no classes imporeted from the file: {0}", sFileToLoad); else { var fileName = Path.GetFileName(sFileToLoad); if (false == cirDataAnalysis.dCirDataFilesLoaded.ContainsKey(fileName)) { cirDataAnalysis.dCirDataFilesLoaded.Add(Path.GetFileName(sFileToLoad), assemblyCirData); } addO2CirDataFile(cirDataAnalysis, assemblyCirData, runRemapXrefs); } } else DI.log.error("Droped *.exe or *.dll file was not a .Net assembly: {0}", sFileToLoad); break; case "*.xml": if (CirLoad.isFileACirDumpFile(sFileToLoad)) addO2CirDataFile(cirDataAnalysis, sFileToLoad,useCachedVersionIfAvailable); break; default: if (showNotSupportedExtensionError) DI.log.error( "Could not process file dropped (it it not a CirData file or a .NET assembly: {0}", sFileToLoad); break; } } catch (Exception ex) { DI.log.error( "in loadFileIntoCirDataAnalysisObject, error {0} while loading {1} : ", sFileToLoad, ex.Message); } }
// for now only add the mappings, but need to check for all other variables public static void mergeFunctions(ICirDataAnalysis cirDataAnalysis, ICirFunction functionHost, ICirFunction functionToMerge) { // map properties foreach (var propertyInfo in DI.reflection.getProperties(typeof(ICirFunction))) // assign value if for this property: // functionHost == null && functionToMerge != null // functionHost == false && functionToMerge == true if ((DI.reflection.getProperty(propertyInfo.Name, functionHost) == null && DI.reflection.getProperty(propertyInfo.Name, functionToMerge) != null) || (DI.reflection.getProperty(propertyInfo.Name, functionHost) != null && DI.reflection.getProperty(propertyInfo.Name, functionHost) is bool && (bool)DI.reflection.getProperty(propertyInfo.Name, functionHost) == false && DI.reflection.getProperty(propertyInfo.Name, functionToMerge) != null && (bool)DI.reflection.getProperty(propertyInfo.Name, functionToMerge) == true)) DI.reflection.setProperty(propertyInfo.Name, functionHost, DI.reflection.getProperty(propertyInfo.Name, functionToMerge)); // ensure the class bClassHasMethodsWithControlFlowGraphs value is uptodate if (functionHost.HasControlFlowGraph && functionHost.ParentClass != null) functionHost.ParentClass.bClassHasMethodsWithControlFlowGraphs = true; for (int i = 0; i < functionToMerge.FunctionIsCalledBy.Count; i++) { var isCalledBy = functionToMerge.FunctionIsCalledBy[i]; var cirFunctionRef = getFunctionRef(cirDataAnalysis, isCalledBy.cirFunction); // big change here when isCalledBy was changed to be a CirFunctionCall object (check if this works ok) bool found = false; foreach (var functionCall in functionHost.FunctionIsCalledBy) if (functionCall.cirFunction == cirFunctionRef) found = true; if (found == false) functionHost.FunctionIsCalledBy.Add(new CirFunctionCall(cirFunctionRef)); // make sure the is calledBy is there //if (false == functionHost.FunctionIsCalledBy.Contains(cirFunctionRef)) // functionHost.FunctionIsCalledBy.Add(cirFunctionRef); /* if (isCalledBy != cirFunctionRef) // means they are different and we need to fix the xRef functionToMerge.FunctionIsCalledBy[i] = cirFunctionRef;*/ } if (functionToMerge.FunctionsCalled.Count > 0 && functionHost.FunctionsCalled.Count != functionToMerge.FunctionsCalled.Count) { if (functionHost.FunctionsCalled.Count == 0) functionHost.FunctionsCalled = functionToMerge.FunctionsCalled; else DI.log.error("something is wrong in mergeFunctions (on functionHost.FunctionsCalledSequence.Count == 0) for {0}", functionHost.FunctionSignature); } if (functionToMerge.FunctionsCalledUniqueList.Count > 0 && functionHost.FunctionsCalledUniqueList.Count != functionToMerge.FunctionsCalledUniqueList.Count) { if (functionHost.FunctionsCalledUniqueList.Count == 0) functionHost.FunctionsCalledUniqueList = functionToMerge.FunctionsCalledUniqueList; else DI.log.error("something is wrong in mergeFunctions (on functionHost.FunctionsCalledUniqueList.Count == 0) for {0}", functionHost.FunctionSignature); } /*foreach (var isCalledBy in functionToMerge.) { var cirFunctionRef = getFunctionRef(cirDataAnalysis, isCalledBy); if (false == functionHost.FunctionIsCalledBy.Contains(cirFunctionRef)) functionHost.FunctionIsCalledBy.Add(cirFunctionRef); }*/ }
public static ICirData createCirDataFromCirDataAnalysis(ICirDataAnalysis cirDataAnalysis) { if (cirDataAnalysis == null) return null; var cirData = new CirData { dClasses_bySignature = cirDataAnalysis.dCirClass_bySignature, dFunctions_bySignature = cirDataAnalysis.dCirFunction_bySignature, }; return cirData; }
public void setO2CirDataAnalysisObject(ICirDataAnalysis cirDataAalysis) { fcdAnalysis = cirDataAalysis; }