private static void GenerateHeaderGuard(string SearchPath, params string[] Extension)
        {
            string[] files = FileSystemUtilites.GetAllFiles(SearchPath, Extension);

            foreach (string filePath in files)
            {
                if (IsForbiddenPath(filePath))
                {
                    continue;
                }

                List <string> lines = new List <string>(File.ReadAllLines(filePath));

                string macroName = Path.GetFileName(filePath).ToUpper().Replace('.', '_');

                string controlStatement = "#ifndef " + macroName;
                string defineStatement  = "#define " + macroName;
                string endStatement     = "#endif // " + macroName;

                int i = Find(controlStatement, lines);
                if (i != 1)
                {
                    if (i != -1)
                    {
                        lines.RemoveAt(i);
                    }

                    lines.Insert(1, controlStatement);
                }

                i = Find(defineStatement, lines);
                if (i != 2)
                {
                    if (i != -1)
                    {
                        lines.RemoveAt(i);
                    }

                    lines.Insert(2, defineStatement);
                }

                i = Find(endStatement, lines);
                if (i != lines.Count - 1)
                {
                    if (i != -1)
                    {
                        lines.RemoveAt(i);
                    }

                    lines.Add(endStatement);
                }

                File.WriteAllLines(filePath, lines.ToArray());
            }
        }
        private static void GenerateLicenseAgreement(string SearchPath, params string[] Extension)
        {
            string[] files = FileSystemUtilites.GetAllFiles(SearchPath, Extension);

            foreach (string filePath in files)
            {
                if (IsForbiddenPath(filePath))
                {
                    continue;
                }

                List <string> lines = new List <string>(File.ReadAllLines(filePath));

                int i = Find("// Copyright", lines);
                if (i == 0)
                {
                    lines[0] = Copyright_Text;
                }
                else
                {
                    if (i != -1)
                    {
                        lines.RemoveAt(i);
                    }

                    lines.Insert(0, Copyright_Text);
                }

                i = Find(PragmaOnce_Text, lines);
                if (i > -1)
                {
                    lines.RemoveAt(i);
                }

                File.WriteAllLines(filePath, lines.ToArray());
            }
        }
        private static void IncludeFilesCorrection(string SearchPath, params string[] Extension)
        {
            string[] files = FileSystemUtilites.GetAllFiles(SearchPath, Extension);

            foreach (string filePath in files)
            {
                if (IsForbiddenPath(filePath))
                {
                    continue;
                }

                List <string> lines = new List <string>(File.ReadAllLines(filePath));

                for (int i = 0; i < lines.Count; i++)
                {
                    string line = lines[i];

                    if (!line.StartsWith("#include"))
                    {
                        continue;
                    }

                    int index = line.IndexOf('"');
                    if (index != -1)
                    {
                        line = line.Remove(index, 1).Insert(index, "<");

                        index = line.IndexOf('"');
                        line  = line.Remove(index, 1).Insert(index, ">");
                    }

                    line = line.Replace('/', '\\');

                    if (!line.ToLower().Contains("public") && !line.ToLower().Contains("private"))
                    {
                        index = line.IndexOf('<');

                        if (index == -1)
                        {
                            continue;
                        }

                        index++;
                        string file = line.Substring(index, line.IndexOf('>') - index);

                        string[] foundFiles = FileSystemUtilites.GetAllFiles(SearchPath, Path.GetFileName(file));

                        if (foundFiles.Length == 0)
                        {
                            continue;
                        }

                        string includeFilePath = foundFiles[0];

                        if (IsThirdpartyPath(includeFilePath) || IsIntermediatePath(includeFilePath))
                        {
                            continue;
                        }

                        bool isPublic = includeFilePath.Contains("Public");

                        line = line.Insert(index, (isPublic ? "Public" : "Private") + EnvironmentHelper.PathSeparator);
                    }

                    lines[i] = line;
                }

                File.WriteAllLines(filePath, lines.ToArray());
            }
        }
Exemplo n.º 4
0
        private bool BuildRulesLibrary()
        {
            if (rulesLibrary != null)
            {
                foreach (SourceBuilder builder in sourceBuilders.Values)
                {
                    builder.State = SourceBuilder.States.NotBuilt;
                }

                return(true);
            }

            const string ProjectName = "Modules";
            string       projectDir  = intermediateDirectory + ProjectName + EnvironmentHelper.PathSeparator;

            if (!Directory.Exists(projectDir))
            {
                Directory.CreateDirectory(projectDir);
            }

            CSProjectFileGenerator csproj = new CSProjectFileGenerator();

            csproj.FrameworkVersion = CSProjectFileGenerator.FrameworkVersions.v4_5;
            csproj.AssemblyName     = ProjectName;
            csproj.OutputPath       = projectDir + "Build" + EnvironmentHelper.PathSeparator;
            csproj.OutputType       = ProjectFileGenerator.OutputTypes.DynamicLinkLibrary;
            csproj.AddReferenceBinaryFile(Assembly.GetExecutingAssembly().Location);

            string[] files = FileSystemUtilites.GetAllFiles(processDirectory, "*" + BuildRules.FilePostfix);

            DateTime startTime = DateTime.Now;

            ConsoleHelper.WriteLineInfo("Building rules starts at " + startTime.ToString());
            ConsoleHelper.WriteLineInfo("Found rules :");

            foreach (string rules in files)
            {
                buildRulesPath.Add(rules);
                csproj.AddCompileFile(rules);

                ConsoleHelper.WriteLineInfo("\t" + Path.GetFileName(rules));
            }

            if (buildRulesPath.Count == 0)
            {
                return(false);
            }

            string csprojPath = projectDir + ProjectName + ".csproj";

            csproj.Generate(csprojPath);

            bool wasSuccessful = false;

            if (compiler.BuildProjectFile(csprojPath))
            {
                rulesLibrary  = Assembly.LoadFile(csproj.OutputPath + ProjectName + ".dll");
                wasSuccessful = true;
            }

            foreach (string buildRule in buildRulesPath)
            {
                string fileName = Path.GetFileNameWithoutExtension(buildRule);
                string typeName = fileName.Replace(".", "");
                Type   type     = rulesLibrary.GetType(typeName);

                if (type == null)
                {
                    ConsoleHelper.WriteLineWarning("In " + fileName + ", type " + typeName + " doesn't exists, building it will be ignore");
                    continue;
                }

                BuildRules rules = (BuildRules)Activator.CreateInstance(type);

                sourceBuilders[rules.TargetName] = new SourceBuilder(rules, Path.GetDirectoryName(buildRule) + EnvironmentHelper.PathSeparator);
            }

            ConsoleHelper.WriteLineInfo("Building rules takes " + (DateTime.Now - startTime).ToHHMMSS());

            return(wasSuccessful);
        }
Exemplo n.º 5
0
 private static void CopyAllFilesToFinalPath(string SourcePath, string Extension)
 {
     FileSystemUtilites.CopyAllFiles(SourcePath, BuildSystem.FinalOutputDirectory, true, "*" + Extension);
 }
Exemplo n.º 6
0
        private void BuildProjectFile()
        {
            LogInfo();

            BuildProjectFile(sourcePathRoot + FileSystemUtilites.PathSeperatorCorrection(rules.ProjectFilePath));
        }
Exemplo n.º 7
0
        private void GenerateAndBuildProjectFile()
        {
            LogInfo();

            VCProjectFileGenerator vcproj = new VCProjectFileGenerator();

            vcproj.AssemblyName       = rules.TargetName;
            vcproj.OutputType         = LibraryUseTypesToOutputType(rules.LibraryUseType);
            vcproj.OutputPath         = BinariesPath;
            vcproj.Optimization       = VCProjectFileGenerator.Optimizations.Disabled;
            vcproj.MinimalRebuild     = true;
            vcproj.PlatformType       = BuildSystem.PlatformType;
            vcproj.BuildConfiguration = BuildSystem.BuildConfiguration;

            if (vcproj.BuildConfiguration == VCProjectFileGenerator.BuildConfigurations.Debug)
            {
                vcproj.GenerateDebugInformation = true;

                //if (rules.LibraryUseType == BuildRules.LibraryUseTypes.Executable)
                //	vcproj.RuntimeLibrary = VCProjectFileGenerator.RuntimeLibraries.MultiThreadedDebug;
                //else
                vcproj.RuntimeLibrary = VCProjectFileGenerator.RuntimeLibraries.MultiThreadedDebugDLL;
            }
            else
            {
                vcproj.GenerateDebugInformation = false;
            }
            {
                //if (rules.LibraryUseType == BuildRules.LibraryUseTypes.Executable)
                //	vcproj.RuntimeLibrary = VCProjectFileGenerator.RuntimeLibraries.MultiThreaded;
                //else
                vcproj.RuntimeLibrary = VCProjectFileGenerator.RuntimeLibraries.MultiThreadedDLL;
            }

            vcproj.PlatformType = VCProjectFileGenerator.PlatformTypes.Win32;

            vcproj.IncludeDirectories += sourcePathRoot;
            vcproj.IncludeDirectories += generatedFilesPath;
            if (rules.DependencyModulesName != null)
            {
                foreach (string dep in rules.DependencyModulesName)
                {
                    if (!BuildSystem.SourceBuilders.ContainsKey(dep))
                    {
                        continue;
                    }

                    SourceBuilder builder = BuildSystem.SourceBuilders[dep];

                    vcproj.IncludeDirectories += builder.sourcePathRoot;

                    if (builder.rules.LibraryUseType == BuildRules.LibraryUseTypes.UseOnly)
                    {
                        string[] libFiles = builder.rules.OutputsFilePath;

                        if (libFiles != null)
                        {
                            foreach (string libFile in libFiles)
                            {
                                vcproj.IncludeLibraries += builder.sourcePathRoot + libFile;
                            }
                        }
                    }
                    else
                    {
                        vcproj.PreprocessorDefinitions += GetAPIPreprocessor(builder.rules, true);

                        string[] libFiles = FileSystemUtilites.GetAllFiles(builder.BinariesPath, "*" + LibExtension);

                        if (libFiles != null)
                        {
                            foreach (string libFile in libFiles)
                            {
                                vcproj.IncludeLibraries += libFile;
                            }
                        }
                    }
                }
            }

            vcproj.PreprocessorDefinitions += GetAPIPreprocessor(rules, false);
            if (rules.PreprocessorDefinitions != null)
            {
                foreach (string def in rules.PreprocessorDefinitions)
                {
                    vcproj.PreprocessorDefinitions += def;
                }
            }

            if (rules.DependencyStaticLibraries != null)
            {
                foreach (string lib in rules.DependencyStaticLibraries)
                {
                    vcproj.IncludeLibraries += lib;
                }
            }

            bool isThisCommonModule = (rules.TargetName == "Common");

            string[] files = FileSystemUtilites.GetAllFiles(sourcePathRoot, "*.h*");
            foreach (string file in files)
            {
                if (BuildSystem.GenerateReflection && !isThisCommonModule)
                {
                    string outputBaseFileName = generatedFilesPath + Path.GetFileNameWithoutExtension(file) + ".Reflection";
                    if (ParseForReflection(file, outputBaseFileName))
                    {
                        vcproj.AddIncludeFile(outputBaseFileName + ".h");
                        vcproj.AddCompileFile(outputBaseFileName + ".cpp");
                    }
                }

                vcproj.AddIncludeFile(file);
            }

            if (rules.IncludeModulesName != null)
            {
                foreach (string moduleName in rules.IncludeModulesName)
                {
                    SourceBuilder builder = BuildSystem.SourceBuilders[moduleName];

                    vcproj.IncludeDirectories      += builder.sourcePathRoot;
                    vcproj.PreprocessorDefinitions += GetEmptyAPIPreprocessor(builder.rules);
                }
            }

            if (rules.AdditionalCompileFile != null)
            {
                foreach (string file in rules.AdditionalCompileFile)
                {
                    string fileInfo = FileSystemUtilites.PathSeperatorCorrection(file);
                    int    index    = fileInfo.IndexOf(EnvironmentHelper.PathSeparator);

                    vcproj.AddCompileFile(BuildSystem.SourceBuilders[fileInfo.Remove(index)].sourcePathRoot + fileInfo.Substring(index + 1));
                }
            }

            files = FileSystemUtilites.GetAllFiles(sourcePathRoot, "*.c", "*.cpp", "*.cxx");
            foreach (string file in files)
            {
                vcproj.AddCompileFile(file);
            }

            string vcprojPath = intermediateModulePath + rules.TargetName + ".vcxproj";

            vcproj.Generate(vcprojPath);

            BuildProjectFile(vcprojPath);
        }