Beispiel #1
0
        private void OnParserResult(IList <SourceFile> sources, ParserResult result)
        {
            string status;

            switch (result.Kind)
            {
            case ParserResultKind.Error:

                status = string.Format("Parsed '{0}' with errors.", sources.Select(s => s.Path).ToCommaDelimitedList());

                SetDiagnosticsStatus(status);

                foreach (var source in sources)
                {
                    var tblHeaderFile = tblSDKHeaderFiles.Single(f => f.HeaderFileName == source.Path);
                    tblHeaderFile.ParsedSuccessfully = false;
                }

                entities.SaveChanges();

                break;

            case ParserResultKind.FileNotFound:

                status = string.Format("File(s) not found '{0}'.", sources.Select(s => s.Path).ToCommaDelimitedList());
                SetDiagnosticsStatus(status);

                break;

            case ParserResultKind.Success:

                status = string.Format("Parsed '{0}' successfully.", sources.Select(s => s.Path).ToCommaDelimitedList());
                SetDiagnosticsStatus(status);

                foreach (var source in sources)
                {
                    var astContext = source.Options.ASTContext;

                    foreach (var unit in astContext.GetUnits())
                    {
                        var notExists     = false;
                        var directoryPair = includeDirectories.SingleOrDefault(p => unit.FileName.AsCaseless().StartsWith(p.Value.FullName));
                        tblSDKHeaderFile tblHeaderFile;
                        tblVendorSDK     similarSdk    = null;
                        bool             hasSimilarSdk = false;

                        if (unit.FileName == "<invalid>")
                        {
                            continue;
                        }

                        if (directoryPair.Key == null)
                        {
                            // has include file from a different version or vendor, attempt to find similar

                            var file = unit.FileName;

                            hasSimilarSdk = tblVendorSDKs.ToList().Any(v =>
                            {
                                if (similarSdk != null)
                                {
                                    return(false);
                                }
                                else if (versionRegex.IsMatch(file))
                                {
                                    var match         = versionRegex.Match(file);
                                    var versionGroup  = match.Groups["version"];
                                    var version       = versionGroup.Value;
                                    var fileBackDated = file.Substitute(versionGroup.Index, versionGroup.Length, v.SdkVersion);

                                    if (includeDirectories.Any(i => fileBackDated.StartsWith(i.Value.FullName)))
                                    {
                                        foreach (var similarPair in includeDirectories.Where(i => fileBackDated.StartsWith(i.Value.FullName)))
                                        {
                                            var tblVendorSdk = similarPair.Key;

                                            if (tblVendorSdk.VendorSdkId == v.VendorSdkId)
                                            {
                                                if (versionRegex.IsMatch(tblVendorSdk.SdkRootFolder))
                                                {
                                                    string newRoot;
                                                    tblVendorSDK tblVendorSdkNew;

                                                    match        = versionRegex.Match(tblVendorSdk.SdkRootFolder);
                                                    versionGroup = match.Groups["version"];
                                                    newRoot      = tblVendorSdk.SdkRootFolder.Substitute(versionGroup.Index, versionGroup.Length, version);

                                                    tblVendorSdkNew = new tblVendorSDK
                                                    {
                                                        VendorSdkId       = Guid.NewGuid(),
                                                        VendorId          = tblVendorSdk.VendorId,
                                                        SdkName           = tblVendorSdk.SdkName,
                                                        SdkVersion        = version,
                                                        SdkRootFolder     = newRoot,
                                                        IncludeFolders    = tblVendorSdk.IncludeFolders,
                                                        SourceFolders     = tblVendorSdk.SourceFolders,
                                                        LibraryFolders    = tblVendorSdk.LibraryFolders,
                                                        ExecutableFolders = tblVendorSdk.ExecutableFolders
                                                    };

                                                    tblVendorSDKs.AddObject(tblVendorSdkNew);
                                                    entities.SaveChanges();

                                                    similarSdk = tblVendorSdkNew;

                                                    return(true);
                                                }
                                            }
                                        }
                                    }
                                }

                                return(false);
                            });
                        }

                        if (hasSimilarSdk)
                        {
                            var sdkId = similarSdk.VendorSdkId;

                            AddIncludes(similarSdk);

                            tblHeaderFile = entities.SaveIfNotExists <tblSDKHeaderFile>(h => h.HeaderFileName == unit.FileName && h.VendorSdkId == sdkId, () =>
                            {
                                notExists = true;

                                return(new tblSDKHeaderFile
                                {
                                    HeaderFileId = Guid.NewGuid(),
                                    HeaderFileName = unit.FileName,
                                    VendorSdkId = similarSdk.VendorSdkId
                                });
                            });
                        }
                        else if (directoryPair.Key == null)
                        {
                            Debugger.Break();

                            tblHeaderFile = entities.SaveIfNotExists <tblSDKHeaderFile>(h => h.HeaderFileName == unit.FileName, () =>
                            {
                                notExists = true;

                                return(new tblSDKHeaderFile
                                {
                                    HeaderFileId = Guid.NewGuid(),
                                    VendorSdkId = null,
                                    HeaderFileName = unit.FileName
                                });
                            });
                        }
                        else
                        {
                            var sdkId = directoryPair.Key.VendorSdkId;

                            tblHeaderFile = entities.SaveIfNotExists <tblSDKHeaderFile>(h => h.HeaderFileName == unit.FileName && h.VendorSdkId == sdkId, () =>
                            {
                                notExists = true;

                                return(new tblSDKHeaderFile
                                {
                                    HeaderFileId = Guid.NewGuid(),
                                    VendorSdkId = directoryPair.Key.VendorSdkId,
                                    HeaderFileName = unit.FileName
                                });
                            });
                        }

                        if (notExists || !tblHeaderFile.IsParsedSuccessfully())
                        {
                            var header       = new Header(unit);
                            var elementCount = header.CacheObjects();
                            var x            = 1;
                            Action <DeclarationContext> recurseAdd = null;

                            recurseAdd = (declarationContext) =>
                            {
                                var tblDeclarationContext = entities.tblSDKHeaderDeclarationContexts.Single(declarationContext.GetWhere(tblHeaderFile));

                                foreach (var _namespace in declarationContext.Namespaces)
                                {
                                    if (declarationContext == header)
                                    {
                                        SetParserProgress(++x, elementCount, "Analyzing {0} with {1} elements", unit.Name, elementCount);
                                    }

                                    _namespace.Save(tblHeaderFile, tblDeclarationContext);

                                    recurseAdd(_namespace);
                                }

                                foreach (var _class in declarationContext.Classes)
                                {
                                    if (declarationContext == header)
                                    {
                                        SetParserProgress(++x, elementCount, "Analyzing {0} with {1} elements", unit.Name, elementCount);
                                    }

                                    _class.Save(tblHeaderFile, tblDeclarationContext);

                                    recurseAdd(_class);
                                }

                                foreach (var template in declarationContext.Templates)
                                {
                                    if (declarationContext == header)
                                    {
                                        SetParserProgress(++x, elementCount, "Analyzing {0} with {1} elements", unit.Name, elementCount);
                                    }

                                    template.Save(tblHeaderFile, tblDeclarationContext);
                                }

                                foreach (var preprocessedEntity in declarationContext.PreprocessedEntities)
                                {
                                    preprocessedEntity.Save(tblHeaderFile, tblDeclarationContext.tblSDKHeaderDeclaration);
                                }

                                foreach (var _enum in declarationContext.Enums)
                                {
                                    if (declarationContext == header)
                                    {
                                        SetParserProgress(++x, elementCount, "Analyzing {0} with {1} elements", unit.Name, elementCount);
                                    }

                                    _enum.Save(tblHeaderFile, tblDeclarationContext);
                                }

                                foreach (var typeAlias in declarationContext.TypeAliases)
                                {
                                    if (declarationContext == header)
                                    {
                                        SetParserProgress(++x, elementCount, "Analyzing {0} with {1} elements", unit.Name, elementCount);
                                    }

                                    typeAlias.Save(tblHeaderFile, tblDeclarationContext);
                                }

                                foreach (var typeDef in declarationContext.TypeDefs)
                                {
                                    if (declarationContext == header)
                                    {
                                        SetParserProgress(++x, elementCount, "Analyzing {0} with {1} elements", unit.Name, elementCount);
                                    }

                                    typeDef.Save(tblHeaderFile, tblDeclarationContext);
                                }

                                foreach (var variable in declarationContext.Variables)
                                {
                                    if (declarationContext == header)
                                    {
                                        SetParserProgress(++x, elementCount, "Analyzing {0} with {1} elements", unit.Name, elementCount);
                                    }

                                    variable.Save(tblHeaderFile, tblDeclarationContext);
                                }

                                foreach (var function in declarationContext.Functions)
                                {
                                    if (declarationContext == header)
                                    {
                                        SetParserProgress(++x, elementCount, "Analyzing {0} with {1} elements", unit.Name, elementCount);
                                    }

                                    function.Save(tblHeaderFile, tblDeclarationContext);
                                }

                                foreach (var friend in declarationContext.Friends)
                                {
                                    if (declarationContext == header)
                                    {
                                        SetParserProgress(++x, elementCount, "Analyzing {0} with {1} elements", unit.Name, elementCount);
                                    }

                                    friend.Save(tblHeaderFile, tblDeclarationContext);
                                }

                                if (declarationContext == header)
                                {
                                    foreach (var macro in header.Macros)
                                    {
                                        if (declarationContext == header)
                                        {
                                            SetParserProgress(++x, elementCount, "Analyzing {0} with {1} elements", unit.Name, elementCount);
                                        }

                                        macro.Save(tblHeaderFile, tblDeclarationContext.tblSDKHeaderDeclaration);
                                    }
                                }
                            };

                            header.Save(tblHeaderFile, true);

                            recurseAdd(header);

                            tblHeaderFile.ParsedSuccessfully = true;

                            entities.SaveChanges();
                        }
                    }
                }

                break;
            }
        }
Beispiel #2
0
        private void AddIncludes(tblVendorSDK tblVendorSdk)
        {
            var rootFolder = tblVendorSdk.SdkRootFolder;

            if (tblVendorSdk.IncludeFolders.IsNullOrEmpty())
            {
                DirectoryInfo includeDirectory;

                includeDirectory = new DirectoryInfo(tblVendorSdk.SdkRootFolder);

                if (includeDirectory.Exists)
                {
                    if (!includeDirectories.ContainsKey(tblVendorSdk))
                    {
                        if (!includeDirectories.Any(p => p.Value.FullName == includeDirectory.FullName))
                        {
                            includeDirectories.Add(tblVendorSdk, includeDirectory);
                        }
                    }
                }
            }
            else
            {
                foreach (var includeFolder in tblVendorSdk.IncludeFolders.Split(';', StringSplitOptions.RemoveEmptyEntries))
                {
                    DirectoryInfo includeDirectory;

                    if (Path.IsPathRooted(includeFolder))
                    {
                        includeDirectory = new DirectoryInfo(includeFolder);
                    }
                    else
                    {
                        var path = Path.GetFullPath(Path.Combine(rootFolder, includeFolder));

                        includeDirectory = new DirectoryInfo(Path.GetFullPath(path));
                    }

                    if (includeDirectory.Exists)
                    {
                        if (!includeDirectories.ContainsKey(tblVendorSdk))
                        {
                            if (!includeDirectories.Any(p => p.Value.FullName == includeDirectory.FullName))
                            {
                                includeDirectories.Add(tblVendorSdk, includeDirectory);
                            }
                        }
                    }
                }
            }

            if (tblVendorSdk.LibraryFolders.IsNullOrEmpty())
            {
                DirectoryInfo libDirectory;

                libDirectory = new DirectoryInfo(tblVendorSdk.SdkRootFolder);

                if (libDirectory.Exists)
                {
                    if (!libraryDirectories.ContainsKey(tblVendorSdk))
                    {
                        if (!libraryDirectories.Any(p => p.Value.FullName == libDirectory.FullName))
                        {
                            libraryDirectories.Add(tblVendorSdk, libDirectory);
                        }
                    }
                }
            }
            else
            {
                foreach (var libFolder in tblVendorSdk.LibraryFolders.Split(';', StringSplitOptions.RemoveEmptyEntries))
                {
                    DirectoryInfo libDirectory;

                    if (Path.IsPathRooted(libFolder))
                    {
                        libDirectory = new DirectoryInfo(libFolder);
                    }
                    else
                    {
                        var path = Path.GetFullPath(Path.Combine(rootFolder, libFolder));

                        libDirectory = new DirectoryInfo(Path.GetFullPath(path));
                    }

                    if (libDirectory.Exists)
                    {
                        if (!libraryDirectories.ContainsKey(tblVendorSdk))
                        {
                            if (!libraryDirectories.Any(p => p.Value.FullName == libDirectory.FullName))
                            {
                                libraryDirectories.Add(tblVendorSdk, libDirectory);
                            }
                        }
                    }
                }
            }
        }