1049 lines
31 KiB
C++
1049 lines
31 KiB
C++
// tools/build_check.cpp - Fast native C++ build helper tool for Juliet project
|
|
// Replaces all PowerShell scripts (build_helper.ps1, check_target.ps1, clean_unity.ps1, summary_helper.ps1)
|
|
#ifndef NOMINMAX
|
|
#define NOMINMAX
|
|
#endif
|
|
#ifndef WIN32_LEAN_AND_MEAN
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#endif
|
|
#include <windows.h>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <cassert>
|
|
|
|
// ============================================================================
|
|
// Minimal string / path helpers (no STL, no std::filesystem — pure speed)
|
|
// ============================================================================
|
|
|
|
static constexpr int MaxPath = 1024;
|
|
static constexpr int MaxFiles = 4096;
|
|
static constexpr int MaxHashEntries = 512;
|
|
|
|
struct FixedString
|
|
{
|
|
char Data[MaxPath];
|
|
int Length;
|
|
|
|
FixedString() : Data{}, Length(0) {}
|
|
|
|
void Set(const char* str)
|
|
{
|
|
assert(str != nullptr);
|
|
Length = 0;
|
|
while (str[Length] != '\0' && Length < MaxPath - 1)
|
|
{
|
|
Data[Length] = str[Length];
|
|
Length++;
|
|
}
|
|
Data[Length] = '\0';
|
|
}
|
|
|
|
void Set(const char* str, int len)
|
|
{
|
|
assert(str != nullptr);
|
|
assert(len >= 0 && len < MaxPath);
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
Data[i] = str[i];
|
|
}
|
|
Data[len] = '\0';
|
|
Length = len;
|
|
}
|
|
|
|
void Append(const char* str)
|
|
{
|
|
assert(str != nullptr);
|
|
int i = 0;
|
|
while (str[i] != '\0' && Length < MaxPath - 1)
|
|
{
|
|
Data[Length++] = str[i++];
|
|
}
|
|
Data[Length] = '\0';
|
|
}
|
|
|
|
void AppendChar(char c)
|
|
{
|
|
if (Length < MaxPath - 1)
|
|
{
|
|
Data[Length++] = c;
|
|
Data[Length] = '\0';
|
|
}
|
|
}
|
|
|
|
[[nodiscard]] bool Equals(const char* other) const
|
|
{
|
|
assert(other != nullptr);
|
|
return strcmp(Data, other) == 0;
|
|
}
|
|
|
|
[[nodiscard]] bool EqualsNoCase(const char* other) const
|
|
{
|
|
assert(other != nullptr);
|
|
return _stricmp(Data, other) == 0;
|
|
}
|
|
};
|
|
|
|
[[nodiscard]] static bool StringContains(const char* haystack, const char* needle)
|
|
{
|
|
assert(haystack != nullptr);
|
|
assert(needle != nullptr);
|
|
return strstr(haystack, needle) != nullptr;
|
|
}
|
|
|
|
[[nodiscard]] static bool EndsWithNoCase(const char* str, const char* suffix)
|
|
{
|
|
assert(str != nullptr);
|
|
assert(suffix != nullptr);
|
|
int strLen = static_cast<int>(strlen(str));
|
|
int sufLen = static_cast<int>(strlen(suffix));
|
|
if (sufLen > strLen)
|
|
{
|
|
return false;
|
|
}
|
|
return _stricmp(str + strLen - sufLen, suffix) == 0;
|
|
}
|
|
|
|
// ============================================================================
|
|
// File I/O helpers using Win32
|
|
// ============================================================================
|
|
|
|
struct FileContent
|
|
{
|
|
char* Data;
|
|
DWORD Size;
|
|
};
|
|
|
|
[[nodiscard]] static FileContent ReadEntireFile(const char* path)
|
|
{
|
|
assert(path != nullptr);
|
|
FileContent result = {nullptr, 0};
|
|
HANDLE file = CreateFileA(path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
|
|
if (file == INVALID_HANDLE_VALUE)
|
|
{
|
|
return result;
|
|
}
|
|
DWORD size = GetFileSize(file, nullptr);
|
|
if (size == INVALID_FILE_SIZE || size == 0)
|
|
{
|
|
CloseHandle(file);
|
|
return result;
|
|
}
|
|
char* buffer = static_cast<char*>(HeapAlloc(GetProcessHeap(), 0, size + 1));
|
|
if (buffer == nullptr)
|
|
{
|
|
CloseHandle(file);
|
|
return result;
|
|
}
|
|
DWORD bytesRead = 0;
|
|
ReadFile(file, buffer, size, &bytesRead, nullptr);
|
|
CloseHandle(file);
|
|
buffer[bytesRead] = '\0';
|
|
result.Data = buffer;
|
|
result.Size = bytesRead;
|
|
return result;
|
|
}
|
|
|
|
static void FreeFileContent(FileContent& content)
|
|
{
|
|
if (content.Data != nullptr)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, content.Data);
|
|
content.Data = nullptr;
|
|
content.Size = 0;
|
|
}
|
|
}
|
|
|
|
static bool WriteEntireFile(const char* path, const char* data, DWORD size)
|
|
{
|
|
assert(path != nullptr);
|
|
assert(data != nullptr);
|
|
HANDLE file = CreateFileA(path, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
|
|
if (file == INVALID_HANDLE_VALUE)
|
|
{
|
|
return false;
|
|
}
|
|
DWORD written = 0;
|
|
WriteFile(file, data, size, &written, nullptr);
|
|
CloseHandle(file);
|
|
return written == size;
|
|
}
|
|
|
|
[[nodiscard]] static bool FileExists(const char* path)
|
|
{
|
|
assert(path != nullptr);
|
|
DWORD attribs = GetFileAttributesA(path);
|
|
return (attribs != INVALID_FILE_ATTRIBUTES) && !(attribs & FILE_ATTRIBUTE_DIRECTORY);
|
|
}
|
|
|
|
[[nodiscard]] static bool DirectoryExists(const char* path)
|
|
{
|
|
assert(path != nullptr);
|
|
DWORD attribs = GetFileAttributesA(path);
|
|
return (attribs != INVALID_FILE_ATTRIBUTES) && (attribs & FILE_ATTRIBUTE_DIRECTORY);
|
|
}
|
|
|
|
static void EnsureDirectoryExists(const char* path)
|
|
{
|
|
assert(path != nullptr);
|
|
CreateDirectoryA(path, nullptr);
|
|
}
|
|
|
|
[[nodiscard]] static int64_t GetFileModTimeInt64(const char* path)
|
|
{
|
|
assert(path != nullptr);
|
|
WIN32_FILE_ATTRIBUTE_DATA data;
|
|
if (GetFileAttributesExA(path, GetFileExInfoStandard, &data))
|
|
{
|
|
ULARGE_INTEGER li;
|
|
li.LowPart = data.ftLastWriteTime.dwLowDateTime;
|
|
li.HighPart = data.ftLastWriteTime.dwHighDateTime;
|
|
return static_cast<int64_t>(li.QuadPart);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// ============================================================================
|
|
// FNV-1a hash
|
|
// ============================================================================
|
|
|
|
[[nodiscard]] static uint64_t ComputeFnv1aHash(const char* data, DWORD size)
|
|
{
|
|
assert(data != nullptr);
|
|
uint64_t hash = 14695981039346656037ULL;
|
|
for (DWORD i = 0; i < size; i++)
|
|
{
|
|
hash ^= static_cast<uint64_t>(static_cast<unsigned char>(data[i]));
|
|
hash *= 1099511628211ULL;
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Hash cache for unity files
|
|
// ============================================================================
|
|
|
|
struct HashEntry
|
|
{
|
|
FixedString Path;
|
|
char HashStr[32];
|
|
};
|
|
|
|
struct HashCache
|
|
{
|
|
HashEntry* Entries;
|
|
int Count;
|
|
|
|
HashCache()
|
|
{
|
|
Entries = static_cast<HashEntry*>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(HashEntry) * MaxHashEntries));
|
|
assert(Entries != nullptr);
|
|
Count = 0;
|
|
}
|
|
|
|
~HashCache()
|
|
{
|
|
if (Entries != nullptr)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, Entries);
|
|
Entries = nullptr;
|
|
}
|
|
}
|
|
|
|
HashCache(const HashCache&) = delete;
|
|
HashCache& operator=(const HashCache&) = delete;
|
|
|
|
[[nodiscard]] const char* Find(const char* path) const
|
|
{
|
|
assert(path != nullptr);
|
|
for (int i = 0; i < Count; i++)
|
|
{
|
|
if (Entries[i].Path.Equals(path))
|
|
{
|
|
return Entries[i].HashStr;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void Add(const char* path, const char* hash)
|
|
{
|
|
assert(path != nullptr);
|
|
assert(hash != nullptr);
|
|
if (Count < MaxHashEntries && Entries != nullptr)
|
|
{
|
|
Entries[Count].Path.Set(path);
|
|
strncpy_s(Entries[Count].HashStr, hash, sizeof(Entries[Count].HashStr) - 1);
|
|
Count++;
|
|
}
|
|
}
|
|
};
|
|
|
|
static void LoadHashCache(const char* cachePath, HashCache& cache)
|
|
{
|
|
assert(cachePath != nullptr);
|
|
FileContent content = ReadEntireFile(cachePath);
|
|
if (content.Data == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const char* pos = content.Data;
|
|
while (*pos != '\0')
|
|
{
|
|
const char* lineStart = pos;
|
|
while (*pos != '\0' && *pos != '\n' && *pos != '\r')
|
|
{
|
|
pos++;
|
|
}
|
|
int lineLen = static_cast<int>(pos - lineStart);
|
|
|
|
if (lineLen > 0)
|
|
{
|
|
const char* sep = nullptr;
|
|
for (const char* c = lineStart; c < lineStart + lineLen; c++)
|
|
{
|
|
if (*c == '=')
|
|
{
|
|
sep = c;
|
|
break;
|
|
}
|
|
}
|
|
if (sep != nullptr)
|
|
{
|
|
FixedString key;
|
|
key.Set(lineStart, static_cast<int>(sep - lineStart));
|
|
|
|
int valLen = static_cast<int>((lineStart + lineLen) - (sep + 1));
|
|
char val[32] = {};
|
|
if (valLen > 0 && valLen < 32)
|
|
{
|
|
memcpy(val, sep + 1, static_cast<size_t>(valLen));
|
|
val[valLen] = '\0';
|
|
}
|
|
cache.Add(key.Data, val);
|
|
}
|
|
}
|
|
|
|
while (*pos == '\n' || *pos == '\r')
|
|
{
|
|
pos++;
|
|
}
|
|
}
|
|
|
|
FreeFileContent(content);
|
|
}
|
|
|
|
static void SaveHashCache(const char* cachePath, const HashCache& cache)
|
|
{
|
|
assert(cachePath != nullptr);
|
|
size_t bufSize = static_cast<size_t>(MaxHashEntries) * (MaxPath + 32 + 2);
|
|
char* buffer = static_cast<char*>(HeapAlloc(GetProcessHeap(), 0, bufSize));
|
|
if (buffer == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
int offset = 0;
|
|
|
|
for (int i = 0; i < cache.Count; i++)
|
|
{
|
|
int written = sprintf_s(buffer + offset, bufSize - static_cast<size_t>(offset),
|
|
"%s=%s\n", cache.Entries[i].Path.Data, cache.Entries[i].HashStr);
|
|
if (written > 0)
|
|
{
|
|
offset += written;
|
|
}
|
|
}
|
|
|
|
WriteEntireFile(cachePath, buffer, static_cast<DWORD>(offset));
|
|
HeapFree(GetProcessHeap(), 0, buffer);
|
|
}
|
|
|
|
// ============================================================================
|
|
// Clean #pragma message lines and compute hash for a unity file
|
|
// ============================================================================
|
|
|
|
struct CleanResult
|
|
{
|
|
char HashStr[32];
|
|
bool WasCleaned;
|
|
};
|
|
|
|
[[nodiscard]] static CleanResult CleanAndHashUnityFile(const char* filePath)
|
|
{
|
|
assert(filePath != nullptr);
|
|
CleanResult result = {{}, false};
|
|
|
|
FileContent content = ReadEntireFile(filePath);
|
|
if (content.Data == nullptr)
|
|
{
|
|
result.HashStr[0] = '\0';
|
|
return result;
|
|
}
|
|
|
|
bool hasPragma = StringContains(content.Data, "#pragma message");
|
|
|
|
if (hasPragma)
|
|
{
|
|
// Filter out #pragma message lines
|
|
char* filtered = static_cast<char*>(HeapAlloc(GetProcessHeap(), 0, content.Size + 1));
|
|
assert(filtered != nullptr);
|
|
DWORD filteredSize = 0;
|
|
|
|
const char* pos = content.Data;
|
|
while (*pos != '\0')
|
|
{
|
|
const char* lineStart = pos;
|
|
while (*pos != '\0' && *pos != '\n')
|
|
{
|
|
pos++;
|
|
}
|
|
bool skipLine = false;
|
|
for (const char* c = lineStart; c < pos; c++)
|
|
{
|
|
if (c + 15 <= content.Data + content.Size && memcmp(c, "#pragma message", 15) == 0)
|
|
{
|
|
skipLine = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!skipLine)
|
|
{
|
|
DWORD lineLen = static_cast<DWORD>(pos - lineStart);
|
|
memcpy(filtered + filteredSize, lineStart, lineLen);
|
|
filteredSize += lineLen;
|
|
if (*pos == '\n')
|
|
{
|
|
filtered[filteredSize++] = '\n';
|
|
}
|
|
}
|
|
if (*pos == '\n')
|
|
{
|
|
pos++;
|
|
}
|
|
}
|
|
filtered[filteredSize] = '\0';
|
|
|
|
WriteEntireFile(filePath, filtered, filteredSize);
|
|
|
|
uint64_t hashVal = ComputeFnv1aHash(filtered, filteredSize);
|
|
sprintf_s(result.HashStr, "%llu", hashVal);
|
|
result.WasCleaned = true;
|
|
|
|
HeapFree(GetProcessHeap(), 0, filtered);
|
|
}
|
|
else
|
|
{
|
|
uint64_t hashVal = ComputeFnv1aHash(content.Data, content.Size);
|
|
sprintf_s(result.HashStr, "%llu", hashVal);
|
|
}
|
|
|
|
FreeFileContent(content);
|
|
return result;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Recursive directory scan for newest source file time
|
|
// ============================================================================
|
|
|
|
[[nodiscard]] static int64_t GetNewestSourceTimeRecursive(const char* dirPath)
|
|
{
|
|
assert(dirPath != nullptr);
|
|
int64_t newest = 0;
|
|
|
|
if (!DirectoryExists(dirPath))
|
|
{
|
|
return newest;
|
|
}
|
|
|
|
FixedString searchPath;
|
|
searchPath.Set(dirPath);
|
|
searchPath.Append("\\*");
|
|
|
|
WIN32_FIND_DATAA findData;
|
|
HANDLE hFind = FindFirstFileA(searchPath.Data, &findData);
|
|
if (hFind == INVALID_HANDLE_VALUE)
|
|
{
|
|
return newest;
|
|
}
|
|
|
|
do
|
|
{
|
|
if (findData.cFileName[0] == '.' &&
|
|
(findData.cFileName[1] == '\0' || (findData.cFileName[1] == '.' && findData.cFileName[2] == '\0')))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
FixedString fullPath;
|
|
fullPath.Set(dirPath);
|
|
fullPath.AppendChar('\\');
|
|
fullPath.Append(findData.cFileName);
|
|
|
|
if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
|
{
|
|
int64_t subNewest = GetNewestSourceTimeRecursive(fullPath.Data);
|
|
if (subNewest > newest)
|
|
{
|
|
newest = subNewest;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (EndsWithNoCase(findData.cFileName, ".cpp") ||
|
|
EndsWithNoCase(findData.cFileName, ".h") ||
|
|
EndsWithNoCase(findData.cFileName, ".hpp") ||
|
|
EndsWithNoCase(findData.cFileName, ".inl") ||
|
|
EndsWithNoCase(findData.cFileName, ".c"))
|
|
{
|
|
ULARGE_INTEGER li;
|
|
li.LowPart = findData.ftLastWriteTime.dwLowDateTime;
|
|
li.HighPart = findData.ftLastWriteTime.dwHighDateTime;
|
|
int64_t ft = static_cast<int64_t>(li.QuadPart);
|
|
if (ft > newest)
|
|
{
|
|
newest = ft;
|
|
}
|
|
}
|
|
}
|
|
} while (FindNextFileA(hFind, &findData));
|
|
|
|
FindClose(hFind);
|
|
return newest;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Collect unity files recursively from Intermediate/
|
|
// ============================================================================
|
|
|
|
struct FilePathList
|
|
{
|
|
FixedString* Paths;
|
|
int Count;
|
|
|
|
FilePathList()
|
|
{
|
|
Paths = static_cast<FixedString*>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(FixedString) * MaxFiles));
|
|
assert(Paths != nullptr);
|
|
Count = 0;
|
|
}
|
|
|
|
~FilePathList()
|
|
{
|
|
if (Paths != nullptr)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, Paths);
|
|
Paths = nullptr;
|
|
}
|
|
}
|
|
|
|
FilePathList(const FilePathList&) = delete;
|
|
FilePathList& operator=(const FilePathList&) = delete;
|
|
|
|
void Add(const char* path)
|
|
{
|
|
assert(path != nullptr);
|
|
if (Count < MaxFiles && Paths != nullptr)
|
|
{
|
|
Paths[Count].Set(path);
|
|
Count++;
|
|
}
|
|
}
|
|
};
|
|
|
|
static void CollectUnityFiles(const char* dirPath, FilePathList& list)
|
|
{
|
|
assert(dirPath != nullptr);
|
|
FixedString searchPath;
|
|
searchPath.Set(dirPath);
|
|
searchPath.Append("\\*");
|
|
|
|
WIN32_FIND_DATAA findData;
|
|
HANDLE hFind = FindFirstFileA(searchPath.Data, &findData);
|
|
if (hFind == INVALID_HANDLE_VALUE)
|
|
{
|
|
return;
|
|
}
|
|
|
|
do
|
|
{
|
|
if (findData.cFileName[0] == '.' &&
|
|
(findData.cFileName[1] == '\0' || (findData.cFileName[1] == '.' && findData.cFileName[2] == '\0')))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
FixedString fullPath;
|
|
fullPath.Set(dirPath);
|
|
fullPath.AppendChar('\\');
|
|
fullPath.Append(findData.cFileName);
|
|
|
|
if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
|
{
|
|
CollectUnityFiles(fullPath.Data, list);
|
|
}
|
|
else
|
|
{
|
|
if (StringContains(findData.cFileName, "_Unity") && EndsWithNoCase(findData.cFileName, ".cpp"))
|
|
{
|
|
list.Add(fullPath.Data);
|
|
}
|
|
}
|
|
} while (FindNextFileA(hFind, &findData));
|
|
|
|
FindClose(hFind);
|
|
}
|
|
|
|
// ============================================================================
|
|
// Commands
|
|
// ============================================================================
|
|
|
|
static int CommandStartBuild()
|
|
{
|
|
EnsureDirectoryExists("Intermediate");
|
|
|
|
DeleteFileA("Intermediate\\step_start.tmp");
|
|
DeleteFileA("Intermediate\\step_timings.tmp");
|
|
|
|
FILETIME ft;
|
|
GetSystemTimeAsFileTime(&ft);
|
|
ULARGE_INTEGER li;
|
|
li.LowPart = ft.dwLowDateTime;
|
|
li.HighPart = ft.dwHighDateTime;
|
|
|
|
char buf[32];
|
|
sprintf_s(buf, "%llu", li.QuadPart);
|
|
WriteEntireFile("Intermediate\\build_start.tmp", buf, static_cast<DWORD>(strlen(buf)));
|
|
return 0;
|
|
}
|
|
|
|
static int CommandStartStep(int argc, char* argv[])
|
|
{
|
|
assert(argv != nullptr);
|
|
EnsureDirectoryExists("Intermediate");
|
|
|
|
const char* stepName = (argc > 2 && argv[2] != nullptr) ? argv[2] : "Unnamed Step";
|
|
|
|
FILETIME ft;
|
|
GetSystemTimeAsFileTime(&ft);
|
|
ULARGE_INTEGER li;
|
|
li.LowPart = ft.dwLowDateTime;
|
|
li.HighPart = ft.dwHighDateTime;
|
|
|
|
char buf[MaxPath + 64];
|
|
int len = sprintf_s(buf, "%s\n%llu\n", stepName, li.QuadPart);
|
|
if (len > 0)
|
|
{
|
|
WriteEntireFile("Intermediate\\step_start.tmp", buf, static_cast<DWORD>(len));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int CommandEndStep(int argc, char* argv[])
|
|
{
|
|
assert(argv != nullptr);
|
|
if (!FileExists("Intermediate\\step_start.tmp"))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
FileContent content = ReadEntireFile("Intermediate\\step_start.tmp");
|
|
if (content.Data == nullptr)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
char stepName[MaxPath] = "Unnamed Step";
|
|
uint64_t startTicks = 0;
|
|
|
|
const char* line1End = strchr(content.Data, '\n');
|
|
if (line1End != nullptr)
|
|
{
|
|
int nameLen = static_cast<int>(line1End - content.Data);
|
|
if (nameLen > 0 && nameLen < MaxPath)
|
|
{
|
|
memcpy(stepName, content.Data, static_cast<size_t>(nameLen));
|
|
stepName[nameLen] = '\0';
|
|
}
|
|
sscanf_s(line1End + 1, "%llu", &startTicks);
|
|
}
|
|
FreeFileContent(content);
|
|
DeleteFileA("Intermediate\\step_start.tmp");
|
|
|
|
if (argc > 2 && argv[2] != nullptr && argv[2][0] != '\0')
|
|
{
|
|
strncpy_s(stepName, argv[2], MaxPath - 1);
|
|
}
|
|
|
|
FILETIME ftNow;
|
|
GetSystemTimeAsFileTime(&ftNow);
|
|
ULARGE_INTEGER nowLi;
|
|
nowLi.LowPart = ftNow.dwLowDateTime;
|
|
nowLi.HighPart = ftNow.dwHighDateTime;
|
|
|
|
double elapsedSeconds = static_cast<double>(nowLi.QuadPart - startTicks) / 10000000.0;
|
|
|
|
char appendBuf[MaxPath + 64];
|
|
int appendLen = sprintf_s(appendBuf, "%s|%.3fs\n", stepName, elapsedSeconds);
|
|
if (appendLen > 0)
|
|
{
|
|
FileContent existing = ReadEntireFile("Intermediate\\step_timings.tmp");
|
|
DWORD newSize = static_cast<DWORD>(appendLen) + existing.Size;
|
|
char* combined = static_cast<char*>(HeapAlloc(GetProcessHeap(), 0, newSize + 1));
|
|
if (combined != nullptr)
|
|
{
|
|
DWORD offset = 0;
|
|
if (existing.Data != nullptr && existing.Size > 0)
|
|
{
|
|
memcpy(combined, existing.Data, existing.Size);
|
|
offset = existing.Size;
|
|
}
|
|
memcpy(combined + offset, appendBuf, static_cast<size_t>(appendLen));
|
|
combined[newSize] = '\0';
|
|
WriteEntireFile("Intermediate\\step_timings.tmp", combined, newSize);
|
|
HeapFree(GetProcessHeap(), 0, combined);
|
|
}
|
|
FreeFileContent(existing);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int CommandFinishBuild()
|
|
{
|
|
// Compute elapsed time
|
|
const char* elapsedStr = "0.000s";
|
|
char elapsedBuf[64] = {};
|
|
|
|
if (FileExists("Intermediate\\build_start.tmp"))
|
|
{
|
|
FileContent startContent = ReadEntireFile("Intermediate\\build_start.tmp");
|
|
if (startContent.Data != nullptr)
|
|
{
|
|
uint64_t startTicks = 0;
|
|
sscanf_s(startContent.Data, "%llu", &startTicks);
|
|
FreeFileContent(startContent);
|
|
|
|
FILETIME ftNow;
|
|
GetSystemTimeAsFileTime(&ftNow);
|
|
ULARGE_INTEGER nowLi;
|
|
nowLi.LowPart = ftNow.dwLowDateTime;
|
|
nowLi.HighPart = ftNow.dwHighDateTime;
|
|
|
|
double elapsedSeconds = static_cast<double>(nowLi.QuadPart - startTicks) / 10000000.0;
|
|
|
|
if (elapsedSeconds < 60.0)
|
|
{
|
|
sprintf_s(elapsedBuf, "%.3fs", elapsedSeconds);
|
|
}
|
|
else
|
|
{
|
|
int totalMs = static_cast<int>(elapsedSeconds * 1000.0);
|
|
int hours = totalMs / 3600000;
|
|
int minutes = (totalMs % 3600000) / 60000;
|
|
int seconds = (totalMs % 60000) / 1000;
|
|
int ms = totalMs % 1000;
|
|
sprintf_s(elapsedBuf, "%02d:%02d:%02d.%03d", hours, minutes, seconds, ms);
|
|
}
|
|
elapsedStr = elapsedBuf;
|
|
}
|
|
DeleteFileA("Intermediate\\build_start.tmp");
|
|
}
|
|
|
|
if (FileExists("Intermediate\\step_timings.tmp"))
|
|
{
|
|
FileContent timingsContent = ReadEntireFile("Intermediate\\step_timings.tmp");
|
|
if (timingsContent.Data != nullptr && timingsContent.Size > 0)
|
|
{
|
|
printf("Step Timings:\n");
|
|
const char* pos = timingsContent.Data;
|
|
while (*pos != '\0')
|
|
{
|
|
const char* lineStart = pos;
|
|
while (*pos != '\0' && *pos != '\n' && *pos != '\r')
|
|
{
|
|
pos++;
|
|
}
|
|
int lineLen = static_cast<int>(pos - lineStart);
|
|
while (*pos == '\n' || *pos == '\r')
|
|
{
|
|
pos++;
|
|
}
|
|
|
|
if (lineLen > 0)
|
|
{
|
|
const char* pipePos = nullptr;
|
|
for (const char* p = lineStart; p < lineStart + lineLen; p++)
|
|
{
|
|
if (*p == '|')
|
|
{
|
|
pipePos = p;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (pipePos != nullptr)
|
|
{
|
|
char stepName[MaxPath] = {};
|
|
int nameLen = static_cast<int>(pipePos - lineStart);
|
|
if (nameLen < MaxPath)
|
|
{
|
|
memcpy(stepName, lineStart, static_cast<size_t>(nameLen));
|
|
stepName[nameLen] = '\0';
|
|
}
|
|
|
|
char durationStr[64] = {};
|
|
int durLen = static_cast<int>((lineStart + lineLen) - (pipePos + 1));
|
|
if (durLen < 64)
|
|
{
|
|
memcpy(durationStr, pipePos + 1, static_cast<size_t>(durLen));
|
|
durationStr[durLen] = '\0';
|
|
}
|
|
|
|
printf(" - %-42s : %s\n", stepName, durationStr);
|
|
}
|
|
}
|
|
}
|
|
printf("------------------------------------------------------------------------------\n");
|
|
FreeFileContent(timingsContent);
|
|
}
|
|
DeleteFileA("Intermediate\\step_timings.tmp");
|
|
}
|
|
|
|
printf("Total Duration : %s\n", elapsedStr);
|
|
printf("Output Binaries:\n");
|
|
|
|
if (FileExists("Intermediate\\built_outputs.tmp"))
|
|
{
|
|
FileContent outputsContent = ReadEntireFile("Intermediate\\built_outputs.tmp");
|
|
bool anyPrinted = false;
|
|
|
|
if (outputsContent.Data != nullptr)
|
|
{
|
|
const char* pos = outputsContent.Data;
|
|
while (*pos != '\0')
|
|
{
|
|
const char* lineStart = pos;
|
|
while (*pos != '\0' && *pos != '\n' && *pos != '\r')
|
|
{
|
|
pos++;
|
|
}
|
|
int lineLen = static_cast<int>(pos - lineStart);
|
|
while (*pos == '\n' || *pos == '\r')
|
|
{
|
|
pos++;
|
|
}
|
|
|
|
if (lineLen > 0)
|
|
{
|
|
char filePath[MaxPath];
|
|
if (lineLen < MaxPath)
|
|
{
|
|
memcpy(filePath, lineStart, static_cast<size_t>(lineLen));
|
|
filePath[lineLen] = '\0';
|
|
|
|
if (FileExists(filePath))
|
|
{
|
|
WIN32_FILE_ATTRIBUTE_DATA fileData;
|
|
if (GetFileAttributesExA(filePath, GetFileExInfoStandard, &fileData))
|
|
{
|
|
ULARGE_INTEGER fileSize;
|
|
fileSize.LowPart = fileData.nFileSizeLow;
|
|
fileSize.HighPart = fileData.nFileSizeHigh;
|
|
double sizeMB = static_cast<double>(fileSize.QuadPart) / (1024.0 * 1024.0);
|
|
printf(" - %s (%.2f MB)\n", filePath, sizeMB);
|
|
anyPrinted = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
FreeFileContent(outputsContent);
|
|
}
|
|
|
|
if (!anyPrinted)
|
|
{
|
|
printf(" - None built in this session (all requested targets up-to-date)\n");
|
|
}
|
|
DeleteFileA("Intermediate\\built_outputs.tmp");
|
|
}
|
|
else
|
|
{
|
|
printf(" - None built in this session (all requested targets up-to-date)\n");
|
|
}
|
|
|
|
fflush(stdout);
|
|
return 0;
|
|
}
|
|
|
|
static int CommandEvaluate(int argc, char* argv[])
|
|
{
|
|
LARGE_INTEGER perfStart, perfEnd, perfFreq;
|
|
QueryPerformanceCounter(&perfStart);
|
|
QueryPerformanceFrequency(&perfFreq);
|
|
|
|
const char* cfg = (argc > 2) ? argv[2] : "Debug";
|
|
bool targetJuliet = (argc > 3) && argv[3][0] == '1';
|
|
bool targetGame = (argc > 4) && argv[4][0] == '1';
|
|
bool targetRomeo = (argc > 5) && argv[5][0] == '1';
|
|
bool targetShader = (argc > 6) && argv[6][0] == '1';
|
|
|
|
EnsureDirectoryExists("Intermediate");
|
|
|
|
// 1. Process unity files: clean #pragma message, compute hashes, detect changes
|
|
HashCache oldCache;
|
|
LoadHashCache("Intermediate\\.unity_hashes_cache", oldCache);
|
|
|
|
HashCache newCache;
|
|
bool unityChanged = false;
|
|
|
|
FilePathList unityFiles;
|
|
CollectUnityFiles("Intermediate", unityFiles);
|
|
|
|
if (unityFiles.Count == 0)
|
|
{
|
|
unityChanged = true;
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < unityFiles.Count; i++)
|
|
{
|
|
CleanResult cr = CleanAndHashUnityFile(unityFiles.Paths[i].Data);
|
|
newCache.Add(unityFiles.Paths[i].Data, cr.HashStr);
|
|
|
|
const char* oldHash = oldCache.Find(unityFiles.Paths[i].Data);
|
|
if (oldHash == nullptr || strcmp(oldHash, cr.HashStr) != 0)
|
|
{
|
|
unityChanged = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
SaveHashCache("Intermediate\\.unity_hashes_cache", newCache);
|
|
|
|
// 2. Scan source directory modification times once
|
|
int64_t julietTime = GetNewestSourceTimeRecursive("Juliet");
|
|
int64_t gameTime = GetNewestSourceTimeRecursive("Game");
|
|
int64_t imguiTime = GetNewestSourceTimeRecursive("External\\imgui");
|
|
int64_t appTime = GetNewestSourceTimeRecursive("JulietApp");
|
|
int64_t romeoTime = GetNewestSourceTimeRecursive("Romeo");
|
|
int64_t shaderTime = GetNewestSourceTimeRecursive("JulietShaderCompiler");
|
|
|
|
auto MaxTime = [](int64_t a, int64_t b) -> int64_t { return (a > b) ? a : b; };
|
|
|
|
int64_t julietCombined = MaxTime(julietTime, imguiTime);
|
|
int64_t gameCombined = MaxTime(MaxTime(julietTime, gameTime), imguiTime);
|
|
int64_t appCombined = MaxTime(MaxTime(MaxTime(julietTime, gameTime), appTime), imguiTime);
|
|
int64_t romeoCombined = MaxTime(MaxTime(julietTime, romeoTime), imguiTime);
|
|
int64_t shaderCombined = MaxTime(MaxTime(julietTime, shaderTime), imguiTime);
|
|
|
|
// Build paths for target binaries
|
|
char binDir[MaxPath];
|
|
char intDir[MaxPath];
|
|
sprintf_s(binDir, "bin\\x64-%s", cfg);
|
|
sprintf_s(intDir, "Intermediate\\x64-%s", cfg);
|
|
|
|
auto IsUpToDate = [](const char* targetPath, int64_t newestSourceTime) -> bool
|
|
{
|
|
assert(targetPath != nullptr);
|
|
if (!FileExists(targetPath))
|
|
{
|
|
return false;
|
|
}
|
|
return GetFileModTimeInt64(targetPath) >= newestSourceTime;
|
|
};
|
|
|
|
char path[MaxPath];
|
|
|
|
sprintf_s(path, "%s\\Juliet_Unity1.obj", intDir);
|
|
bool julietNeed = unityChanged || !IsUpToDate(path, julietCombined);
|
|
|
|
sprintf_s(path, "%s\\ImGui_Unity1.obj", intDir);
|
|
bool imguiNeed = unityChanged || !IsUpToDate(path, imguiTime);
|
|
|
|
bool gameNeed = false;
|
|
if (targetJuliet || targetGame)
|
|
{
|
|
sprintf_s(path, "%s\\Game.dll", binDir);
|
|
gameNeed = julietNeed || unityChanged || !IsUpToDate(path, gameCombined);
|
|
}
|
|
|
|
bool julietAppNeed = false;
|
|
if (targetJuliet)
|
|
{
|
|
sprintf_s(path, "%s\\JulietApp.exe", binDir);
|
|
julietAppNeed = gameNeed || unityChanged || !IsUpToDate(path, appCombined);
|
|
}
|
|
|
|
bool romeoNeed = false;
|
|
if (targetRomeo)
|
|
{
|
|
sprintf_s(path, "%s\\Romeo.exe", binDir);
|
|
romeoNeed = julietNeed || unityChanged || !IsUpToDate(path, romeoCombined);
|
|
}
|
|
|
|
bool shaderNeed = false;
|
|
if (targetShader && DirectoryExists("Intermediate\\JulietShaderCompiler"))
|
|
{
|
|
sprintf_s(path, "%s\\JulietShaderCompiler.exe", binDir);
|
|
shaderNeed = julietNeed || unityChanged || !IsUpToDate(path, shaderCombined);
|
|
}
|
|
|
|
QueryPerformanceCounter(&perfEnd);
|
|
double durationMs = static_cast<double>(perfEnd.QuadPart - perfStart.QuadPart) * 1000.0 / static_cast<double>(perfFreq.QuadPart);
|
|
printf("[PERF] Fast Native C++ EvaluateConfig: %.1f ms\n", durationMs);
|
|
|
|
// Write results
|
|
char statusBuf[512];
|
|
int statusLen = sprintf_s(statusBuf,
|
|
"FASTBUILD_UNITY_CHANGED=%d\n"
|
|
"JULIET_NEED_COMPILE=%d\n"
|
|
"IMGUI_NEED_COMPILE=%d\n"
|
|
"GAME_NEED_COMPILE=%d\n"
|
|
"JULIETAPP_NEED_COMPILE=%d\n"
|
|
"ROMEO_NEED_COMPILE=%d\n"
|
|
"SHADER_NEED_COMPILE=%d\n",
|
|
unityChanged ? 1 : 0,
|
|
julietNeed ? 1 : 0,
|
|
imguiNeed ? 1 : 0,
|
|
gameNeed ? 1 : 0,
|
|
julietAppNeed ? 1 : 0,
|
|
romeoNeed ? 1 : 0,
|
|
shaderNeed ? 1 : 0);
|
|
|
|
WriteEntireFile("Intermediate\\config_status.tmp", statusBuf, static_cast<DWORD>(statusLen));
|
|
fflush(stdout);
|
|
return 0;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Main entry point
|
|
// ============================================================================
|
|
|
|
int main(int argc, char* argv[])
|
|
{
|
|
if (argc < 2)
|
|
{
|
|
printf("Usage: build_check <command> [args...]\n");
|
|
printf("Commands:\n");
|
|
printf(" start_build Record build start timestamp\n");
|
|
printf(" start_step <name> Record start timestamp of a build step\n");
|
|
printf(" end_step [<name>] Record duration of current step\n");
|
|
printf(" finish_build Print build summary (elapsed time, step timings, built binaries)\n");
|
|
printf(" evaluate <cfg> <juliet> <game> <romeo> <shader> Evaluate rebuild needs\n");
|
|
printf(" check_alive Returns 0 immediately to test execution\n");
|
|
return 1;
|
|
}
|
|
|
|
const char* cmd = argv[1];
|
|
if (strcmp(cmd, "check_alive") == 0) return 0;
|
|
if (strcmp(cmd, "start_build") == 0) return CommandStartBuild();
|
|
if (strcmp(cmd, "start_step") == 0) return CommandStartStep(argc, argv);
|
|
if (strcmp(cmd, "end_step") == 0) return CommandEndStep(argc, argv);
|
|
if (strcmp(cmd, "finish_build")== 0) return CommandFinishBuild();
|
|
if (strcmp(cmd, "evaluate") == 0) return CommandEvaluate(argc, argv);
|
|
|
|
printf("[ERROR] Unknown command: %s\n", cmd);
|
|
return 1;
|
|
}
|