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 bool createConsolidatedCirDataFile(String sPathToCirDumpFiles, String sTargetCirDataFile,
                                                  bool bStoreControlFlowBlockRawDataInsideCirDataFile)
 {
     DI.log.debug("Creating Consolidated CirData file");
     try
     {
         List <String> lsCirDumpFiles = Files.getFilesFromDir_returnFullPath(sPathToCirDumpFiles);
         var           fcdCirData     = new CirData
         {
             bStoreControlFlowBlockRawDataInsideCirDataFile =
                 bStoreControlFlowBlockRawDataInsideCirDataFile
         };
         if (lsCirDumpFiles.Count == 0)
         {
             DI.log.error("No CirDump to process (were created during scan?)");
         }
         else
         {
             DI.log.debug("in loadCirDumpXmlFile_andPopulateDictionariesWithXrefs");
             foreach (String sFile in lsCirDumpFiles)
             {
                 try
                 {
                     fcdCirData.dSymbols = new Dictionary <string, string>();
                     fcdCirData.dTemp_Functions_bySymbolDef = new Dictionary <string, ICirFunction>();
                     CirLoad.loadCirDumpXmlFile_andPopulateDictionariesWithXrefs(sFile, fcdCirData, true);
                 }
                 catch (Exception ex)
                 {
                     DI.log.error("In createConsolidatedCirDataFile, error while processing file {0}: {1}",
                                  sFile, ex.Message);
                 }
             }
             DI.log.debug("in saveSerializedO2CirDataObjectToFile");
             CirDataUtils.saveSerializedO2CirDataObjectToFile(fcdCirData, sTargetCirDataFile);
             return(true);
         }
     }
     catch (Exception ex)
     {
         DI.log.error("In createConsolidatedCirDataFile: {0}:", ex.Message);
     }
     return(false);
 }
        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);
            }
        }