Esempio n. 1
0
        public IEnumerable <ISourceInfo> FindSources(IList <IPackageEntry> fileInfos, ISymbolInfo pdbFile)
        {
            IList <string> originalPaths;

            using (var pdbStream = pdbFile.File.GetStream())
                originalPaths = pdbSourceExtractor.ReadSources(pdbStream);

            var files = fileInfos
                        .Select(f =>
                                new
            {
                Split = f.FullPath.ToLowerInvariant().Split(new [] { '\\', '/' }, StringSplitOptions.RemoveEmptyEntries),
                Info  = f,
            }
                                )
                        .ToArray();

            foreach (var originalPath in originalPaths)
            {
                var path = originalPath.ToLowerInvariant().Split(new[] { '\\', '/' }, StringSplitOptions.RemoveEmptyEntries);

                var proposition = files
                                  .Select(f => new
                {
                    Level = ComputeLevel(path, f.Split),
                    f.Info
                })
                                  .Where(f => f.Level > 0)
                                  .OrderByDescending(f => f.Level)
                                  .Select(f => f.Info)
                                  .FirstOrDefault();

                if (proposition != null)
                {
                    using (var stream = proposition.GetStream())
                        yield return new SourceInfo()
                               {
                                   OriginalPath = originalPath,
                                   File         = proposition,
                                   Hash         = sourceStoreManager.ReadHash(stream)
                               };
                }
            }
        }
Esempio n. 2
0
        public IEnumerable <ISourceInfo> FindSources(IList <IPackageEntry> fileInfos, IBinaryInfo peFile, ISymbolInfo pdbFile)
        {
            string         pdbName = Path.GetFileNameWithoutExtension(pdbFile.File.FullPath);
            IList <string> originalPaths;

            using (var peStream = peFile.File.Stream)
                using (var pdbStream = pdbFile.File.Stream)
                    originalPaths = pdbSourceExtractor.ReadSources(peStream, pdbStream);

            if (originalPaths.Any())
            {
                string maxCommonOriginalPath = GetMaxCommonPath(originalPaths.Select(o => o.Replace('\\', Path.DirectorySeparatorChar).Replace('/', Path.DirectorySeparatorChar)));
                if (originalPaths.Count == 1)
                {
                    maxCommonOriginalPath = Path.GetDirectoryName(maxCommonOriginalPath);
                }

                //Clean fileInfos
                var originalPathsExtensions = originalPaths.Select(Path.GetExtension).Distinct().ToArray();
                fileInfos = fileInfos.Where(f => originalPathsExtensions.Any(o => string.Equals(Path.GetExtension(f.FullPath), o, StringComparison.OrdinalIgnoreCase))).ToArray();


                string maxCommonFileInfosPath = GetMaxCommonPath(fileInfos.Select(o => o.FullPath.Replace('\\', Path.DirectorySeparatorChar).Replace('/', Path.DirectorySeparatorChar)));
                if (fileInfos.Count == 1)
                {
                    maxCommonFileInfosPath = Path.GetDirectoryName(maxCommonFileInfosPath);
                }


                foreach (var originalPath in originalPaths)
                {
                    var actualPath = GetActualPaths(fileInfos, originalPath.Replace('\\', Path.DirectorySeparatorChar).Replace('/', Path.DirectorySeparatorChar), maxCommonOriginalPath, maxCommonFileInfosPath);

                    string keyPath = Path.Combine(pdbName, originalPath.Substring(maxCommonOriginalPath.Length + 1)).Replace('\\', '/');

                    if (log.IsDebugEnabled)
                    {
                        log.DebugFormat("Found '{0}' -> '{1}' ('{2}') ", originalPath, actualPath != null ? actualPath.FullPath : "NOT FOUND", keyPath);
                    }

                    if (actualPath != null)
                    {
                        using (var stream = actualPath.Stream)
                            yield return new SourceInfo(pdbFile)
                                   {
                                       OriginalPath = originalPath,
                                       ActualPath   = actualPath,
                                       KeyPath      = keyPath,
                                       Md5Hash      = sourceStoreManager.ReadHash(stream)
                                   }
                    }
                    ;
                    else
                    {
                        yield return new SourceInfo(pdbFile)
                               {
                                   OriginalPath = originalPath,
                                   KeyPath      = keyPath,
                               }
                    };
                }
                yield break;
            }

            yield break;
        }