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());
}
}
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);
}
private static void CopyAllFilesToFinalPath(string SourcePath, string Extension)
{
FileSystemUtilites.CopyAllFiles(SourcePath, BuildSystem.FinalOutputDirectory, true, "*" + Extension);
}
private void BuildProjectFile()
{
LogInfo();
BuildProjectFile(sourcePathRoot + FileSystemUtilites.PathSeperatorCorrection(rules.ProjectFilePath));
}
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);
}
