Patedam/Juliet
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Removing named namespace from code base.

Browse Source
This commit is contained in:
Patedam
2026-08-22 21:39:21 -04:00
parent 678795b793
commit 4180622d6a
158 changed files with 12260 additions and 12648 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Romeo/src/AiGenerator.cpp
+38 -38
View File
@@ -10,7 +10,7 @@
namespace Romeo
{
static Juliet::String ReadFileContent(Juliet::Arena* arena, const Juliet::String& path)
static String ReadFileContent(Arena* arena, const String& path)
{
Assert(arena != nullptr);
if (path.Size == 0)
@@ -20,7 +20,7 @@ namespace Romeo
char pathBuf[512];
size_t copyLen = path.Size < 511 ? path.Size : 511;
memcpy(pathBuf, path.Data, copyLen);
memcpy(pathBuf, path.Str, copyLen);
pathBuf[copyLen] = '\0';
FILE* f = nullptr;
@@ -45,7 +45,7 @@ namespace Romeo
size = 20480;
}
char* buf = Juliet::ArenaPushArray<char>(arena, static_cast<size_t>(size + 1) JULIET_DEBUG_PARAM("FileReadContent"));
char* buf = ArenaPushArray<char>(arena, static_cast<size_t>(size + 1) JULIET_DEBUG_PARAM("FileReadContent"));
size_t readBytes = fread(buf, 1, static_cast<size_t>(size), f);
buf[readBytes] = '\0';
@@ -53,7 +53,7 @@ namespace Romeo
return { buf, readBytes };
}
static Juliet::String GetEnvironmentVar(Juliet::Arena* arena, const char* varName)
static String GetEnvironmentVar(Arena* arena, const char* varName)
{
Assert(arena != nullptr);
Assert(varName != nullptr);
@@ -64,7 +64,7 @@ namespace Romeo
return {};
}
char* buf = Juliet::ArenaPushArray<char>(arena, size JULIET_DEBUG_PARAM("EnvVar"));
char* buf = ArenaPushArray<char>(arena, size JULIET_DEBUG_PARAM("EnvVar"));
GetEnvironmentVariableA(varName, buf, size);
return { buf, static_cast<size_t>(size - 1) };
}
@@ -72,13 +72,13 @@ namespace Romeo
static bool G_OllamaReady = false;
static bool PostWithRetry(
Juliet::Arena* arena,
const Juliet::String& host,
Arena* arena,
const String& host,
int port,
const Juliet::String& path,
const String& path,
bool isHttps,
const Juliet::String& requestBody,
Juliet::String& outResponse
const String& requestBody,
String& outResponse
)
{
if (isHttps)
@@ -109,14 +109,14 @@ namespace Romeo
return false;
}
static bool PullOllamaModelIfNeeded(Juliet::Arena* arena, const Juliet::String& host, int port, const Juliet::String& modelName)
static bool PullOllamaModelIfNeeded(Arena* arena, const String& host, int port, const String& modelName)
{
size_t bodyCap = modelName.Size + 64;
char* showBodyBuf = Juliet::ArenaPushArray<char>(arena, bodyCap JULIET_DEBUG_PARAM("ShowBody"));
char* showBodyBuf = ArenaPushArray<char>(arena, bodyCap JULIET_DEBUG_PARAM("ShowBody"));
int showLen = snprintf(showBodyBuf, bodyCap, "{\"name\":\"%.*s\"}", static_cast<int>(modelName.Size), CStr(modelName));
Juliet::String showBody = { showBodyBuf, static_cast<size_t>(showLen > 0 ? showLen : 0) };
String showBody = { showBodyBuf, static_cast<size_t>(showLen > 0 ? showLen : 0) };
Juliet::String showResponse = {};
String showResponse = {};
bool showSuccess = PostWithRetry(arena, host, port, ConstString("/api/show"), false, showBody, showResponse);
bool needsPull = false;
@@ -129,7 +129,7 @@ namespace Romeo
JsonValue root = {};
if (Json_Parse(arena, showResponse, root))
{
Juliet::String errorMsg = {};
String errorMsg = {};
if (Json_Query(root, "error", errorMsg))
{
needsPull = true;
@@ -147,11 +147,11 @@ namespace Romeo
static_cast<int>(modelName.Size), CStr(modelName));
OutputDebugStringA("Romeo AI: Model not found. Pulling model...\n");
char* pullBodyBuf = Juliet::ArenaPushArray<char>(arena, bodyCap + 32 JULIET_DEBUG_PARAM("PullBody"));
char* pullBodyBuf = ArenaPushArray<char>(arena, bodyCap + 32 JULIET_DEBUG_PARAM("PullBody"));
int pullLen = snprintf(pullBodyBuf, bodyCap + 32, "{\"name\":\"%.*s\",\"stream\":false}", static_cast<int>(modelName.Size), CStr(modelName));
Juliet::String pullBody = { pullBodyBuf, static_cast<size_t>(pullLen > 0 ? pullLen : 0) };
String pullBody = { pullBodyBuf, static_cast<size_t>(pullLen > 0 ? pullLen : 0) };
Juliet::String pullResponse = {};
String pullResponse = {};
bool pullSuccess = PostWithRetry(arena, host, port, ConstString("/api/pull"), false, pullBody, pullResponse);
if (pullSuccess)
{
@@ -170,7 +170,7 @@ namespace Romeo
return true;
}
static Juliet::String CleanAndFormatDescription(Juliet::Arena* arena, const Juliet::String& rawResponse, bool enableCoT)
static String CleanAndFormatDescription(Arena* arena, const String& rawResponse, bool enableCoT)
{
Assert(arena != nullptr);
if (rawResponse.Size == 0)
@@ -184,8 +184,8 @@ namespace Romeo
const char* thinkStart = strstr(pStr, "<think>");
const char* thinkEnd = thinkStart ? strstr(thinkStart, "</think>") : nullptr;
Juliet::String thinkContent = {};
Juliet::String mainContent = {};
String thinkContent = {};
String mainContent = {};
if (thinkStart && thinkEnd && thinkEnd > thinkStart)
{
@@ -220,7 +220,7 @@ namespace Romeo
if (enableCoT && thinkContent.Size > 0)
{
size_t resultCap = thinkContent.Size + mLen + 256;
char* resultBuf = Juliet::ArenaPushArray<char>(arena, resultCap JULIET_DEBUG_PARAM("CoTFormattedDesc"));
char* resultBuf = ArenaPushArray<char>(arena, resultCap JULIET_DEBUG_PARAM("CoTFormattedDesc"));
int written = snprintf(resultBuf, resultCap,
"<details>\n<summary>Chain of Thought</summary>\n\n%.*s\n\n</details>\n\n%.*s",
static_cast<int>(thinkContent.Size), CStr(thinkContent),
@@ -229,30 +229,30 @@ namespace Romeo
return { resultBuf, static_cast<size_t>(written > 0 ? written : 0) };
}
char* resultBuf = Juliet::ArenaPushArray<char>(arena, mLen + 1 JULIET_DEBUG_PARAM("CleanedDesc"));
char* resultBuf = ArenaPushArray<char>(arena, mLen + 1 JULIET_DEBUG_PARAM("CleanedDesc"));
memcpy(resultBuf, mPtr, mLen);
resultBuf[mLen] = '\0';
return { resultBuf, mLen };
}
bool AI_GenerateDescription(
Juliet::Arena* arena,
Arena* arena,
FileEntry& entry
)
{
Assert(arena != nullptr);
Juliet::String headerContent = ReadFileContent(arena, entry.HeaderPath);
Juliet::String cppContent = ReadFileContent(arena, entry.CppPath);
String headerContent = ReadFileContent(arena, entry.HeaderPath);
String cppContent = ReadFileContent(arena, entry.CppPath);
if (headerContent.Size == 0 && cppContent.Size == 0)
{
entry.Description = Juliet::StringCopy(arena, ConstString("*File is empty.*"));
entry.Description = StringCopy(arena, ConstString("*File is empty.*"));
return true;
}
Juliet::String cotEnv = GetEnvironmentVar(arena, "ROMEO_ENABLE_COT");
bool enableCoT = (cotEnv.Size > 0 && (cotEnv.Data[0] == '1' || cotEnv.Data[0] == 't' || cotEnv.Data[0] == 'T' || cotEnv.Data[0] == 'y' || cotEnv.Data[0] == 'Y'));
String cotEnv = GetEnvironmentVar(arena, "ROMEO_ENABLE_COT");
bool enableCoT = (cotEnv.Size > 0 && (cotEnv.Str[0] == '1' || cotEnv.Str[0] == 't' || cotEnv.Str[0] == 'T' || cotEnv.Str[0] == 'y' || cotEnv.Str[0] == 'Y'));
const char* sysPromptNoCoT = "You are a technical documentation assistant. Provide a single, concise, unified paragraph overview (50-80 words) describing the main purpose and design of this C++ component.\n"
"Rules:\n"
@@ -270,7 +270,7 @@ namespace Romeo
const char* sysPrompt = enableCoT ? sysPromptCoT : sysPromptNoCoT;
size_t promptCap = strlen(sysPrompt) + entry.HeaderPath.Size + headerContent.Size + entry.CppPath.Size + cppContent.Size + entry.Description.Size + 512;
char* promptBuf = Juliet::ArenaPushArray<char>(arena, promptCap JULIET_DEBUG_PARAM("PromptBuf"));
char* promptBuf = ArenaPushArray<char>(arena, promptCap JULIET_DEBUG_PARAM("PromptBuf"));
int written = 0;
if (entry.Description.Size > 0)
@@ -306,12 +306,12 @@ namespace Romeo
);
}
Juliet::String prompt = { promptBuf, static_cast<size_t>(written > 0 ? written : 0) };
Juliet::String escapedPrompt = Json_EscapeString(arena, prompt);
String prompt = { promptBuf, static_cast<size_t>(written > 0 ? written : 0) };
String escapedPrompt = Json_EscapeString(arena, prompt);
Juliet::String host = ConstString("127.0.0.1");
String host = ConstString("127.0.0.1");
int port = 11434;
Juliet::String modelName = GetEnvironmentVar(arena, "ROMEO_LLM_MODEL");
String modelName = GetEnvironmentVar(arena, "ROMEO_LLM_MODEL");
if (modelName.Size == 0)
{
modelName = ConstString("qwen2.5-coder:1.5b");
@@ -330,16 +330,16 @@ namespace Romeo
int maxPredictTokens = enableCoT ? 600 : 300;
size_t bodyCap = modelName.Size + escapedPrompt.Size + 512;
char* bodyBuf = Juliet::ArenaPushArray<char>(arena, bodyCap JULIET_DEBUG_PARAM("OllamaBody"));
char* bodyBuf = ArenaPushArray<char>(arena, bodyCap JULIET_DEBUG_PARAM("OllamaBody"));
int bodyLen = snprintf(bodyBuf, bodyCap,
"{\"model\":\"%.*s\",\"prompt\":\"%.*s\",\"stream\":false,\"options\":{\"temperature\":0.2,\"num_predict\":%d}}",
static_cast<int>(modelName.Size), CStr(modelName),
static_cast<int>(escapedPrompt.Size), CStr(escapedPrompt),
maxPredictTokens
);
Juliet::String body = { bodyBuf, static_cast<size_t>(bodyLen > 0 ? bodyLen : 0) };
String body = { bodyBuf, static_cast<size_t>(bodyLen > 0 ? bodyLen : 0) };
Juliet::String response = {};
String response = {};
bool success = PostWithRetry(
arena,
host,
@@ -355,7 +355,7 @@ namespace Romeo
JsonValue root = {};
if (Json_Parse(arena, response, root))
{
Juliet::String desc = {};
String desc = {};
if (Json_Query(root, "response", desc))
{
entry.Description = CleanAndFormatDescription(arena, desc, enableCoT);
Romeo/src/AiGenerator.h
+2 -2
View File
@@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <Core/Common/String.h>
#include "Database.h"
@@ -8,7 +8,7 @@ namespace Romeo
// Generates a description for the file entry using local Ollama or cloud Gemini API.
// Returns true if generation was successful and entry.Description was populated.
[[nodiscard]] bool AI_GenerateDescription(
Juliet::Arena* arena,
Arena* arena,
FileEntry& entry
);
}
Romeo/src/Database.cpp
+26 -26
View File
@@ -6,7 +6,7 @@
namespace Romeo
{
void DB_Init(Database& db, Juliet::Arena* arena)
void DB_Init(Database& db, Arena* arena)
{
printf("Entering DB_Init...\n");
db.DbArena = arena;
@@ -17,10 +17,10 @@ namespace Romeo
struct ScanContext
{
Database* Db;
Juliet::Arena* TempArena;
Arena* TempArena;
};
static void ProcessFile(ScanContext& ctx, const Juliet::String& path, const WIN32_FIND_DATAW& findData)
static void ProcessFile(ScanContext& ctx, const String& path, const WIN32_FIND_DATAW& findData)
{
// Simple filter: only .h and .cpp
const char* pPath = CStr(path);
@@ -67,7 +67,7 @@ namespace Romeo
FileEntry* entry = nullptr;
for (FileEntry& e : ctx.Db->Entries)
{
Juliet::String dbPath = e.HeaderPath.Size > 0 ? e.HeaderPath : e.CppPath;
String dbPath = e.HeaderPath.Size > 0 ? e.HeaderPath : e.CppPath;
if (dbPath.Size > 0)
{
const char* pDbPath = CStr(dbPath);
@@ -102,22 +102,22 @@ namespace Romeo
if (isHeader)
{
entry->HeaderPath = Juliet::StringCopy(ctx.Db->DbArena, path);
entry->HeaderPath = StringCopy(ctx.Db->DbArena, path);
entry->LastModifiedHeader = lastModified;
}
else
{
entry->CppPath = Juliet::StringCopy(ctx.Db->DbArena, path);
entry->CppPath = StringCopy(ctx.Db->DbArena, path);
entry->LastModifiedCpp = lastModified;
}
}
static void ScanDirectoryRecursive(ScanContext& ctx, const Juliet::String& currentDir)
static void ScanDirectoryRecursive(ScanContext& ctx, const String& currentDir)
{
size_t searchPathLen = currentDir.Size + 3; // "\*" + null
char* searchPathBuf = ArenaPushArray<char>(ctx.TempArena, searchPathLen JULIET_DEBUG_PARAM("RomeoDbSearchPathBuf"));
snprintf(searchPathBuf, searchPathLen, "%s\\*", CStr(currentDir));
Juliet::String searchPath = {searchPathBuf, searchPathLen - 1};
String searchPath = {searchPathBuf, searchPathLen - 1};
// Convert to wide string for Win32
int wLen = MultiByteToWideChar(CP_UTF8, 0, CStr(searchPath), -1, nullptr, 0);
@@ -152,7 +152,7 @@ namespace Romeo
size_t fullPathLen = currentDir.Size + 1 + static_cast<size_t>(uLen); // "\" + null
char* fullPathBuf = ArenaPushArray<char>(ctx.TempArena, fullPathLen JULIET_DEBUG_PARAM("RomeoDbFullPathBuf"));
snprintf(fullPathBuf, fullPathLen, "%s\\%s", CStr(currentDir), uFileName);
Juliet::String fullPath = {fullPathBuf, fullPathLen - 1};
String fullPath = {fullPathBuf, fullPathLen - 1};
if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
@@ -171,7 +171,7 @@ namespace Romeo
FindClose(hFind);
}
void DB_ScanWorkspace(Database& db, Juliet::Arena* tempArena, const Juliet::String& rootDir)
void DB_ScanWorkspace(Database& db, Arena* tempArena, const String& rootDir)
{
Assert(tempArena != nullptr);
ScanContext ctx;
@@ -186,7 +186,7 @@ namespace Romeo
{
snprintf(srcDirBuf, sizeof(srcDirBuf), "%s\\Juliet\\src", CStr(rootDir));
}
Juliet::String srcDir = Juliet::StringCopy(tempArena, Juliet::WrapString(srcDirBuf));
String srcDir = StringCopy(tempArena, WrapString(srcDirBuf));
char incDirBuf[512];
snprintf(incDirBuf, sizeof(incDirBuf), "%s\\include", CStr(rootDir));
@@ -195,13 +195,13 @@ namespace Romeo
{
snprintf(incDirBuf, sizeof(incDirBuf), "%s\\Juliet\\include", CStr(rootDir));
}
Juliet::String incDir = Juliet::StringCopy(tempArena, Juliet::WrapString(incDirBuf));
String incDir = StringCopy(tempArena, WrapString(incDirBuf));
ScanDirectoryRecursive(ctx, srcDir);
ScanDirectoryRecursive(ctx, incDir);
}
bool DB_Save(const Database& db, const Juliet::String& filePath)
bool DB_Save(const Database& db, const String& filePath)
{
FILE* file = nullptr;
if (fopen_s(&file, CStr(filePath), "wb") != 0 || !file)
@@ -216,11 +216,11 @@ namespace Romeo
{
uint64_t hLen = entry.HeaderPath.Size;
fwrite(&hLen, sizeof(uint64_t), 1, file);
if (hLen > 0) fwrite(entry.HeaderPath.Data, 1, static_cast<size_t>(hLen), file);
if (hLen > 0) fwrite(entry.HeaderPath.Str, 1, static_cast<size_t>(hLen), file);
uint64_t cLen = entry.CppPath.Size;
fwrite(&cLen, sizeof(uint64_t), 1, file);
if (cLen > 0) fwrite(entry.CppPath.Data, 1, static_cast<size_t>(cLen), file);
if (cLen > 0) fwrite(entry.CppPath.Str, 1, static_cast<size_t>(cLen), file);
fwrite(&entry.LastModifiedHeader, sizeof(uint64_t), 1, file);
fwrite(&entry.LastModifiedCpp, sizeof(uint64_t), 1, file);
@@ -229,14 +229,14 @@ namespace Romeo
uint64_t dLen = entry.Description.Size;
fwrite(&dLen, sizeof(uint64_t), 1, file);
if (dLen > 0) fwrite(entry.Description.Data, 1, static_cast<size_t>(dLen), file);
if (dLen > 0) fwrite(entry.Description.Str, 1, static_cast<size_t>(dLen), file);
}
fclose(file);
return true;
}
bool DB_Load(Database& db, const Juliet::String& filePath)
bool DB_Load(Database& db, const String& filePath)
{
FILE* file = nullptr;
if (fopen_s(&file, CStr(filePath), "rb") != 0 || !file)
@@ -261,20 +261,20 @@ namespace Romeo
if (fread(&hLen, sizeof(uint64_t), 1, file) != 1) break;
if (hLen > 0)
{
entry.HeaderPath.Data = ArenaPushArray<char>(db.DbArena, static_cast<size_t>(hLen + 1) JULIET_DEBUG_PARAM("DbLoadHeader"));
entry.HeaderPath.Str = ArenaPushArray<char>(db.DbArena, static_cast<size_t>(hLen + 1) JULIET_DEBUG_PARAM("DbLoadHeader"));
entry.HeaderPath.Size = static_cast<size_t>(hLen);
fread(entry.HeaderPath.Data, 1, static_cast<size_t>(hLen), file);
entry.HeaderPath.Data[hLen] = '\0';
fread(entry.HeaderPath.Str, 1, static_cast<size_t>(hLen), file);
entry.HeaderPath.Str[hLen] = '\0';
}
uint64_t cLen = 0;
if (fread(&cLen, sizeof(uint64_t), 1, file) != 1) break;
if (cLen > 0)
{
entry.CppPath.Data = ArenaPushArray<char>(db.DbArena, static_cast<size_t>(cLen + 1) JULIET_DEBUG_PARAM("DbLoadCpp"));
entry.CppPath.Str = ArenaPushArray<char>(db.DbArena, static_cast<size_t>(cLen + 1) JULIET_DEBUG_PARAM("DbLoadCpp"));
entry.CppPath.Size = static_cast<size_t>(cLen);
fread(entry.CppPath.Data, 1, static_cast<size_t>(cLen), file);
entry.CppPath.Data[cLen] = '\0';
fread(entry.CppPath.Str, 1, static_cast<size_t>(cLen), file);
entry.CppPath.Str[cLen] = '\0';
}
fread(&entry.LastModifiedHeader, sizeof(uint64_t), 1, file);
@@ -286,10 +286,10 @@ namespace Romeo
if (fread(&dLen, sizeof(uint64_t), 1, file) != 1) break;
if (dLen > 0)
{
entry.Description.Data = ArenaPushArray<char>(db.DbArena, static_cast<size_t>(dLen + 1) JULIET_DEBUG_PARAM("DbLoadDesc"));
entry.Description.Str = ArenaPushArray<char>(db.DbArena, static_cast<size_t>(dLen + 1) JULIET_DEBUG_PARAM("DbLoadDesc"));
entry.Description.Size = static_cast<size_t>(dLen);
fread(entry.Description.Data, 1, static_cast<size_t>(dLen), file);
entry.Description.Data[dLen] = '\0';
fread(entry.Description.Str, 1, static_cast<size_t>(dLen), file);
entry.Description.Str[dLen] = '\0';
}
db.Entries.PushBack(entry);
Romeo/src/Database.h
+11 -11
View File
@@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <Core/Common/String.h>
#include <Core/Container/Vector.h>
@@ -10,8 +10,8 @@ namespace Romeo
{
struct FileEntry
{
Juliet::String HeaderPath;
Juliet::String CppPath;
String HeaderPath;
String CppPath;
// Stored as Windows FILETIME (uint64_t) for easy comparison
uint64_t LastModifiedHeader = 0;
@@ -20,24 +20,24 @@ namespace Romeo
uint64_t LastMarkdownCreatedTime = 0;
uint64_t LastAIGeneratedTime = 0;
Juliet::String Description;
String Description;
};
struct Database
{
Juliet::VectorArena<FileEntry, 512> Entries = {};
Juliet::Arena* DbArena = nullptr;
Juliet::Mutex Mutex;
VectorArena<FileEntry, 512> Entries = {};
Arena* DbArena = nullptr;
Mutex Mutex;
};
// Initialize the DB using the provided memory arena
void DB_Init(Database& db, Juliet::Arena* arena);
void DB_Init(Database& db, Arena* arena);
// Scan a workspace directory for pairs of .h/.cpp and update the database structure.
void DB_ScanWorkspace(Database& db, Juliet::Arena* tempArena, const Juliet::String& rootDir);
void DB_ScanWorkspace(Database& db, Arena* tempArena, const String& rootDir);
// Save and load DB state from disk (e.g. Romeo/docs/romeo_db.json or .bin)
bool DB_Save(const Database& db, const Juliet::String& filePath);
bool DB_Load(Database& db, const Juliet::String& filePath);
bool DB_Save(const Database& db, const String& filePath);
bool DB_Load(Database& db, const String& filePath);
} // namespace Romeo
Romeo/src/HttpClient.cpp
+10 -10
View File
@@ -6,7 +6,7 @@
namespace Romeo
{
static wchar_t* ConvertToWide(Juliet::Arena* arena, const Juliet::String& str)
static wchar_t* ConvertToWide(Arena* arena, const String& str)
{
Assert(arena != nullptr);
if (str.Size == 0)
@@ -18,20 +18,20 @@ namespace Romeo
{
return const_cast<wchar_t*>(L"");
}
wchar_t* wBuf = Juliet::ArenaPushArray<wchar_t>(arena, static_cast<size_t>(wLen + 1) JULIET_DEBUG_PARAM("WideStr"));
wchar_t* wBuf = ArenaPushArray<wchar_t>(arena, static_cast<size_t>(wLen + 1) JULIET_DEBUG_PARAM("WideStr"));
MultiByteToWideChar(CP_UTF8, 0, CStr(str), static_cast<int>(str.Size), wBuf, wLen);
wBuf[wLen] = L'\0';
return wBuf;
}
bool HttpClient::Post(
Juliet::Arena* arena,
const Juliet::String& host,
Arena* arena,
const String& host,
int port,
const Juliet::String& path,
const String& path,
bool isHttps,
const Juliet::String& requestBody,
Juliet::String& outResponse
const String& requestBody,
String& outResponse
)
{
Assert(arena != nullptr);
@@ -101,7 +101,7 @@ namespace Romeo
size_t totalBytes = 0;
size_t capacity = 1024;
char* responseData = Juliet::ArenaPushArray<char>(arena, capacity JULIET_DEBUG_PARAM("HttpResponse"));
char* responseData = ArenaPushArray<char>(arena, capacity JULIET_DEBUG_PARAM("HttpResponse"));
do
{
@@ -124,7 +124,7 @@ namespace Romeo
newCapacity = totalBytes + dwSize + 1;
}
char* newBuf = Juliet::ArenaPushArray<char>(arena, newCapacity JULIET_DEBUG_PARAM("HttpResponseGrow"));
char* newBuf = ArenaPushArray<char>(arena, newCapacity JULIET_DEBUG_PARAM("HttpResponseGrow"));
memcpy(newBuf, responseData, totalBytes);
responseData = newBuf;
capacity = newCapacity;
@@ -157,7 +157,7 @@ namespace Romeo
if (totalBytes > 0)
{
responseData[totalBytes] = '\0';
outResponse.Data = responseData;
outResponse.Str = responseData;
outResponse.Size = totalBytes;
success = true;
}
Romeo/src/HttpClient.h
+6 -6
View File
@@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <Core/Common/String.h>
@@ -10,13 +10,13 @@ namespace Romeo
// Sends a POST request over HTTP/HTTPS.
// Response data is allocated on the provided arena and returned in outResponse.
[[nodiscard]] static bool Post(
Juliet::Arena* arena,
const Juliet::String& host,
Arena* arena,
const String& host,
int port,
const Juliet::String& path,
const String& path,
bool isHttps,
const Juliet::String& requestBody,
Juliet::String& outResponse
const String& requestBody,
String& outResponse
);
};
}
Romeo/src/JsonParser.cpp
+11 -11
View File
@@ -9,7 +9,7 @@ namespace Romeo
{
struct JsonParserState
{
Juliet::Arena* Arena;
Arena* Arena;
const char* Ptr;
const char* End;
};
@@ -30,7 +30,7 @@ namespace Romeo
}
}
static bool ParseString(JsonParserState& state, Juliet::String& outStr)
static bool ParseString(JsonParserState& state, String& outStr)
{
if (state.Ptr >= state.End || *state.Ptr != '"')
{
@@ -69,7 +69,7 @@ namespace Romeo
const char* endQuote = state.Ptr;
state.Ptr++;
char* buf = Juliet::ArenaPushArray<char>(state.Arena, len + 1 JULIET_DEBUG_PARAM("JsonParsedStr"));
char* buf = ArenaPushArray<char>(state.Arena, len + 1 JULIET_DEBUG_PARAM("JsonParsedStr"));
if (hasEscape)
{
@@ -114,14 +114,14 @@ namespace Romeo
readPtr++;
}
buf[writeIdx] = '\0';
outStr.Data = buf;
outStr.Str = buf;
outStr.Size = writeIdx;
}
else
{
memcpy(buf, start, len);
buf[len] = '\0';
outStr.Data = buf;
outStr.Str = buf;
outStr.Size = len;
}
@@ -149,7 +149,7 @@ namespace Romeo
return true;
}
Juliet::String key = {};
String key = {};
if (!ParseString(state, key))
{
return false;
@@ -164,7 +164,7 @@ namespace Romeo
JsonKeyValue kv = {};
kv.Key = key;
kv.Value = Juliet::ArenaPushArray<JsonValue>(state.Arena, 1 JULIET_DEBUG_PARAM("JsonValueRef"));
kv.Value = ArenaPushArray<JsonValue>(state.Arena, 1 JULIET_DEBUG_PARAM("JsonValueRef"));
new (kv.Value) JsonValue();
if (!ParseValue(state, *kv.Value))
@@ -334,7 +334,7 @@ namespace Romeo
return false;
}
bool Json_Parse(Juliet::Arena* arena, const Juliet::String& jsonStr, JsonValue& outValue)
bool Json_Parse(Arena* arena, const String& jsonStr, JsonValue& outValue)
{
Assert(arena != nullptr);
if (jsonStr.Size == 0)
@@ -350,7 +350,7 @@ namespace Romeo
return ParseValue(state, outValue);
}
bool Json_Query(const JsonValue& root, const char* path, Juliet::String& outResult)
bool Json_Query(const JsonValue& root, const char* path, String& outResult)
{
Assert(path != nullptr);
@@ -425,7 +425,7 @@ namespace Romeo
return false;
}
Juliet::String Json_EscapeString(Juliet::Arena* arena, const Juliet::String& str)
String Json_EscapeString(Arena* arena, const String& str)
{
Assert(arena != nullptr);
@@ -450,7 +450,7 @@ namespace Romeo
p++;
}
char* buf = Juliet::ArenaPushArray<char>(arena, escLen + 1 JULIET_DEBUG_PARAM("JsonEscapedStr"));
char* buf = ArenaPushArray<char>(arena, escLen + 1 JULIET_DEBUG_PARAM("JsonEscapedStr"));
char* dst = buf;
p = reinterpret_cast<const unsigned char*>(CStr(str));
while (p < end)
Romeo/src/JsonParser.h
+8 -8
View File
@@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <Core/Common/String.h>
#include <Core/Container/Vector.h>
@@ -19,7 +19,7 @@ namespace Romeo
struct JsonKeyValue
{
Juliet::String Key;
String Key;
// Pointer is used here since JsonValue contains JsonKeyValue, forming mutual dependency
JsonValue* Value = nullptr;
};
@@ -29,18 +29,18 @@ namespace Romeo
JsonType Type = JsonType::Null;
bool BoolVal = false;
double NumVal = 0.0;
Juliet::String StrVal = {};
String StrVal = {};
Juliet::VectorArena<JsonValue, 32> ArrayVal = {};
Juliet::VectorArena<JsonKeyValue, 32> ObjectVal = {};
VectorArena<JsonValue, 32> ArrayVal = {};
VectorArena<JsonKeyValue, 32> ObjectVal = {};
};
// Parses a JSON string. Memory is allocated on the provided arena.
[[nodiscard]] bool Json_Parse(Juliet::Arena* arena, const Juliet::String& jsonStr, JsonValue& outValue);
[[nodiscard]] bool Json_Parse(Arena* arena, const String& jsonStr, JsonValue& outValue);
// Queries a nested string value by path (e.g., "candidates/0/content/parts/0/text" or "response").
[[nodiscard]] bool Json_Query(const JsonValue& root, const char* path, Juliet::String& outResult);
[[nodiscard]] bool Json_Query(const JsonValue& root, const char* path, String& outResult);
// Escapes a string to be safely embedded inside JSON.
[[nodiscard]] Juliet::String Json_EscapeString(Juliet::Arena* arena, const Juliet::String& str);
[[nodiscard]] String Json_EscapeString(Arena* arena, const String& str);
}
Romeo/src/MarkdownGenerator.cpp
+70 -70
View File
@@ -12,12 +12,12 @@ namespace Romeo
{
struct ParsedSymbol
{
Juliet::String Name;
Juliet::String ReturnType;
Juliet::String Parameters;
Juliet::String Type; // "class", "struct", "union", "enum", "enum class", "function"
Juliet::String Namespace;
Juliet::String ClassContext;
String Name;
String ReturnType;
String Parameters;
String Type; // "class", "struct", "union", "enum", "enum class", "function"
String Namespace;
String ClassContext;
bool IsConst = false;
};
@@ -35,7 +35,7 @@ namespace Romeo
struct StringBuilder
{
Juliet::Arena* Arena;
Arena* Arena;
char* Buffer = nullptr;
size_t Size = 0;
size_t Capacity = 0;
@@ -62,7 +62,7 @@ namespace Romeo
{
newCap *= 2;
}
char* newBuf = Juliet::ArenaPushArray<char>(Arena, newCap JULIET_DEBUG_PARAM("StringBuilder"));
char* newBuf = ArenaPushArray<char>(Arena, newCap JULIET_DEBUG_PARAM("StringBuilder"));
if (Buffer)
{
memcpy(newBuf, Buffer, Size);
@@ -82,7 +82,7 @@ namespace Romeo
#endif
};
static Juliet::String ReadFileContent(Juliet::Arena* arena, const char* pathBuf)
static String ReadFileContent(Arena* arena, const char* pathBuf)
{
FILE* f = nullptr;
if (fopen_s(&f, pathBuf, "rb") != 0 || !f)
@@ -100,7 +100,7 @@ namespace Romeo
return {};
}
char* buf = Juliet::ArenaPushArray<char>(arena, static_cast<size_t>(size + 1) JULIET_DEBUG_PARAM("FileReadContent"));
char* buf = ArenaPushArray<char>(arena, static_cast<size_t>(size + 1) JULIET_DEBUG_PARAM("FileReadContent"));
size_t readBytes = fread(buf, 1, static_cast<size_t>(size), f);
buf[readBytes] = '\0';
@@ -108,7 +108,7 @@ namespace Romeo
return { buf, readBytes };
}
static Juliet::String GetRelativeString(const Juliet::String& absolutePath, const Juliet::String& workspaceRoot)
static String GetRelativeString(const String& absolutePath, const String& workspaceRoot)
{
if (absolutePath.Size > workspaceRoot.Size)
{
@@ -151,9 +151,9 @@ namespace Romeo
return absolutePath;
}
static Juliet::String BuildMarkdownFileName(Juliet::Arena* arena, const char* relativeBaseName, size_t baseLen)
static String BuildMarkdownFileName(Arena* arena, const char* relativeBaseName, size_t baseLen)
{
char* buf = Juliet::ArenaPushArray<char>(arena, baseLen + 4 JULIET_DEBUG_PARAM("MdFileName"));
char* buf = ArenaPushArray<char>(arena, baseLen + 4 JULIET_DEBUG_PARAM("MdFileName"));
for (size_t i = 0; i < baseLen; ++i)
{
char c = relativeBaseName[i];
@@ -170,7 +170,7 @@ namespace Romeo
return {buf, baseLen + 3};
}
static Juliet::String Trim(const char* start, const char* end)
static String Trim(const char* start, const char* end)
{
if (end < start)
{
@@ -412,16 +412,16 @@ namespace Romeo
}
static void ParseSymbolsFromFile(
Juliet::Arena* arena,
const Juliet::String& filePath,
Juliet::VectorArena<ParsedSymbol, 128>& outSymbols
Arena* arena,
const String& filePath,
VectorArena<ParsedSymbol, 128>& outSymbols
)
{
Assert(arena != nullptr);
char pathBuf[512];
size_t copyLen = filePath.Size < 511 ? filePath.Size : 511;
memcpy(pathBuf, filePath.Data, copyLen);
memcpy(pathBuf, filePath.Str, copyLen);
pathBuf[copyLen] = '\0';
FILE* srcFile = nullptr;
@@ -437,7 +437,7 @@ namespace Romeo
return;
}
char* buffer = Juliet::ArenaPushArray<char>(arena, static_cast<size_t>(fileSize) + 1 JULIET_DEBUG_PARAM("SourceFileBuffer"));
char* buffer = ArenaPushArray<char>(arena, static_cast<size_t>(fileSize) + 1 JULIET_DEBUG_PARAM("SourceFileBuffer"));
size_t readBytes = fread(buffer, 1, static_cast<size_t>(fileSize), srcFile);
buffer[readBytes] = '\0';
fclose(srcFile);
@@ -555,7 +555,7 @@ namespace Romeo
if (nameT.Length > 0 && nameT.IsIdentifier)
{
ParsedSymbol sym = {};
sym.Name = Juliet::StringCopy(arena, { const_cast<char*>(nameT.Start), nameT.Length });
sym.Name = StringCopy(arena, { const_cast<char*>(nameT.Start), nameT.Length });
if (isEnumClass)
{
sym.Type = ConstString("enum class");
@@ -567,11 +567,11 @@ namespace Romeo
char nsBuf[128];
GetCurrentNamespace(nsBuf, sizeof(nsBuf), namespaceStack, namespaceStackCount);
sym.Namespace = Juliet::StringCopy(arena, Juliet::WrapString(nsBuf));
sym.Namespace = StringCopy(arena, WrapString(nsBuf));
char clBuf[128];
GetCurrentClassContext(clBuf, sizeof(clBuf), classStack, classStackCount);
sym.ClassContext = Juliet::StringCopy(arena, Juliet::WrapString(clBuf));
sym.ClassContext = StringCopy(arena, WrapString(clBuf));
outSymbols.PushBack(sym);
}
@@ -613,17 +613,17 @@ namespace Romeo
// Also store the class itself as a symbol!
ParsedSymbol classSym = {};
classSym.Name = Juliet::StringCopy(arena, Juliet::WrapString(classStack[classStackCount-1].Name));
classSym.Type = Juliet::StringCopy(arena, Juliet::WrapString(pendingClassType));
classSym.Name = StringCopy(arena, WrapString(classStack[classStackCount-1].Name));
classSym.Type = StringCopy(arena, WrapString(pendingClassType));
char nsBuf[128];
GetCurrentNamespace(nsBuf, sizeof(nsBuf), namespaceStack, namespaceStackCount);
classSym.Namespace = Juliet::StringCopy(arena, Juliet::WrapString(nsBuf));
classSym.Namespace = StringCopy(arena, WrapString(nsBuf));
char clBuf[128];
// Get class context *excluding* the one we just pushed
GetCurrentClassContext(clBuf, sizeof(clBuf), classStack, classStackCount - 1);
classSym.ClassContext = Juliet::StringCopy(arena, Juliet::WrapString(clBuf));
classSym.ClassContext = StringCopy(arena, WrapString(clBuf));
outSymbols.PushBack(classSym);
@@ -678,8 +678,8 @@ namespace Romeo
bool isConst = false;
if (matchingParen != nullptr && IsFunctionFollowup(matchingParen, end, opensBody, isConst))
{
Juliet::String returnTypeRaw = Trim(lastStatementEnd, funcNameT.Start);
Juliet::String paramsRaw = Trim(t.Start + 1, matchingParen - 1);
String returnTypeRaw = Trim(lastStatementEnd, funcNameT.Start);
String paramsRaw = Trim(t.Start + 1, matchingParen - 1);
char activeClass[128] = "";
GetCurrentClassContext(activeClass, sizeof(activeClass), classStack, classStackCount);
@@ -706,17 +706,17 @@ namespace Romeo
if (hasReturnType || isConstructorOrDestructor)
{
ParsedSymbol funcSym = {};
funcSym.Name = Juliet::StringCopy(arena, { const_cast<char*>(funcNameT.Start), funcNameT.Length });
funcSym.ReturnType = Juliet::StringCopy(arena, returnTypeRaw);
funcSym.Parameters = Juliet::StringCopy(arena, paramsRaw);
funcSym.Name = StringCopy(arena, { const_cast<char*>(funcNameT.Start), funcNameT.Length });
funcSym.ReturnType = StringCopy(arena, returnTypeRaw);
funcSym.Parameters = StringCopy(arena, paramsRaw);
funcSym.Type = ConstString("function");
funcSym.IsConst = isConst;
char nsBuf[128];
GetCurrentNamespace(nsBuf, sizeof(nsBuf), namespaceStack, namespaceStackCount);
funcSym.Namespace = Juliet::StringCopy(arena, Juliet::WrapString(nsBuf));
funcSym.Namespace = StringCopy(arena, WrapString(nsBuf));
funcSym.ClassContext = Juliet::StringCopy(arena, Juliet::WrapString(activeClass));
funcSym.ClassContext = StringCopy(arena, WrapString(activeClass));
outSymbols.PushBack(funcSym);
}
@@ -727,10 +727,10 @@ namespace Romeo
}
}
static void FormatAndWriteSymbols(StringBuilder& sb, Juliet::Arena* arena, const Juliet::String& filePath)
static void FormatAndWriteSymbols(StringBuilder& sb, Arena* arena, const String& filePath)
{
printf("Romeo: FormatAndWriteSymbols start for %.*s\n", static_cast<int>(filePath.Size), CStr(filePath));
Juliet::VectorArena<ParsedSymbol, 128> symbols = {};
VectorArena<ParsedSymbol, 128> symbols = {};
symbols.Create(arena JULIET_DEBUG_ONLY(, "ParsedSymbols"));
printf("Romeo: Calling ParseSymbolsFromFile...\n");
@@ -745,15 +745,15 @@ namespace Romeo
// Collect all distinct namespaces
printf("Romeo: Collecting namespaces...\n");
Juliet::VectorArena<Juliet::String, 16> namespaces = {};
VectorArena<String, 16> namespaces = {};
namespaces.Create(arena JULIET_DEBUG_ONLY(, "NamespacesList"));
for (const ParsedSymbol& sym : symbols)
{
bool found = false;
for (const Juliet::String& ns : namespaces)
for (const String& ns : namespaces)
{
if (Juliet::StringCompare(ns, sym.Namespace) == 0)
if (StringCompare(ns, sym.Namespace) == 0)
{
found = true;
break;
@@ -766,7 +766,7 @@ namespace Romeo
}
printf("Romeo: Namespace collection done.\n");
for (const Juliet::String& ns : namespaces)
for (const String& ns : namespaces)
{
printf("Romeo: Formatting namespace %.*s...\n", static_cast<int>(ns.Size), CStr(ns));
if (ns.Size > 0)
@@ -782,10 +782,10 @@ namespace Romeo
bool hasTypes = false;
for (const ParsedSymbol& sym : symbols)
{
if (Juliet::StringCompare(sym.Namespace, ns) == 0 &&
(Juliet::StringCompare(sym.Type, ConstString("class")) == 0 ||
Juliet::StringCompare(sym.Type, ConstString("struct")) == 0 ||
Juliet::StringCompare(sym.Type, ConstString("union")) == 0))
if (StringCompare(sym.Namespace, ns) == 0 &&
(StringCompare(sym.Type, ConstString("class")) == 0 ||
StringCompare(sym.Type, ConstString("struct")) == 0 ||
StringCompare(sym.Type, ConstString("union")) == 0))
{
if (!hasTypes)
{
@@ -813,9 +813,9 @@ namespace Romeo
bool hasEnums = false;
for (const ParsedSymbol& sym : symbols)
{
if (Juliet::StringCompare(sym.Namespace, ns) == 0 &&
(Juliet::StringCompare(sym.Type, ConstString("enum")) == 0 ||
Juliet::StringCompare(sym.Type, ConstString("enum class")) == 0))
if (StringCompare(sym.Namespace, ns) == 0 &&
(StringCompare(sym.Type, ConstString("enum")) == 0 ||
StringCompare(sym.Type, ConstString("enum class")) == 0))
{
if (!hasEnums)
{
@@ -843,8 +843,8 @@ namespace Romeo
bool hasFuncs = false;
for (const ParsedSymbol& sym : symbols)
{
if (Juliet::StringCompare(sym.Namespace, ns) == 0 &&
Juliet::StringCompare(sym.Type, ConstString("function")) == 0)
if (StringCompare(sym.Namespace, ns) == 0 &&
StringCompare(sym.Type, ConstString("function")) == 0)
{
if (!hasFuncs)
{
@@ -871,7 +871,7 @@ namespace Romeo
}
}
void MD_GenerateDocumentation(Database& db, const Juliet::String& workspaceRoot, const Juliet::String& docsDir)
void MD_GenerateDocumentation(Database& db, const String& workspaceRoot, const String& docsDir)
{
EnsureDirectoryExists(CStr(docsDir));
@@ -912,13 +912,13 @@ namespace Romeo
uint64_t currentTime = (static_cast<uint64_t>(ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
// Temporary arena for parsing symbols and formatting
Juliet::ArenaParams params{};
Juliet::Arena* tempArena = Juliet::ArenaAllocate(params JULIET_DEBUG_PARAM("MdGeneratorTempArena"));
ArenaParams params{};
Arena* tempArena = ArenaAllocate(params);
Assert(tempArena != nullptr);
// Separate arena for AI generation (gets cleared after each file to prevent exhaustion)
Juliet::ArenaParams aiParams{};
Juliet::Arena* aiArena = Juliet::ArenaAllocate(aiParams JULIET_DEBUG_PARAM("AiGeneratorArena"));
ArenaParams aiParams{};
Arena* aiArena = ArenaAllocate(aiParams);
Assert(aiArena != nullptr);
size_t fileIndex = 0;
@@ -927,7 +927,7 @@ namespace Romeo
for (FileEntry& entry : db.Entries)
{
fileIndex++;
const Juliet::String& primaryPath = (entry.HeaderPath.Size > 0) ? entry.HeaderPath : entry.CppPath;
const String& primaryPath = (entry.HeaderPath.Size > 0) ? entry.HeaderPath : entry.CppPath;
if (primaryPath.Size == 0)
{
continue;
@@ -941,11 +941,11 @@ namespace Romeo
continue;
}
Juliet::String relStr = GetRelativeString(primaryPath, workspaceRoot);
String relStr = GetRelativeString(primaryPath, workspaceRoot);
char baseName[512];
size_t copyLen = relStr.Size < 511 ? relStr.Size : 511;
memcpy(baseName, relStr.Data, copyLen);
memcpy(baseName, relStr.Str, copyLen);
baseName[copyLen] = '\0';
size_t baseLen = strlen(baseName);
@@ -960,7 +960,7 @@ namespace Romeo
baseLen -= 2;
}
Juliet::String mdFileName = BuildMarkdownFileName(db.DbArena, baseName, baseLen);
String mdFileName = BuildMarkdownFileName(db.DbArena, baseName, baseLen);
fprintf(overviewFile, "- [%s](%s)\n", baseName, CStr(mdFileName));
@@ -996,11 +996,11 @@ namespace Romeo
printf("Romeo: [%zu/%zu] Generating AI description for '%s'...\n",
fileIndex, totalFiles, baseName);
Juliet::ArenaClear(aiArena);
ArenaClear(aiArena);
if (AI_GenerateDescription(aiArena, entry))
{
// Copy the description to the persistent db arena so it survives aiArena clear
entry.Description = Juliet::StringCopy(db.DbArena, entry.Description);
entry.Description = StringCopy(db.DbArena, entry.Description);
entry.LastAIGeneratedTime = currentTime;
printf("Romeo: [%zu/%zu] Done.\n", fileIndex, totalFiles);
}
@@ -1011,7 +1011,7 @@ namespace Romeo
}
}
Juliet::ArenaClear(tempArena);
ArenaClear(tempArena);
char mdFilePath[512];
snprintf(mdFilePath, sizeof(mdFilePath), "%s\\%s", CStr(docsDir), CStr(mdFileName));
@@ -1022,20 +1022,20 @@ namespace Romeo
sb.Append("## Source Files\n");
if (entry.HeaderPath.Size > 0)
{
Juliet::String hRel = GetRelativeString(entry.HeaderPath, workspaceRoot);
sb.Append("- Header: `%.*s`\n", static_cast<int>(hRel.Size), hRel.Data);
String hRel = GetRelativeString(entry.HeaderPath, workspaceRoot);
sb.Append("- Header: `%.*s`\n", static_cast<int>(hRel.Size), hRel.Str);
}
if (entry.CppPath.Size > 0)
{
Juliet::String cRel = GetRelativeString(entry.CppPath, workspaceRoot);
sb.Append("- Source: `%.*s`\n", static_cast<int>(cRel.Size), cRel.Data);
String cRel = GetRelativeString(entry.CppPath, workspaceRoot);
sb.Append("- Source: `%.*s`\n", static_cast<int>(cRel.Size), cRel.Str);
}
sb.Append("\n");
sb.Append("## AI Description\n");
if (entry.Description.Size > 0)
{
sb.Append("%.*s\n", static_cast<int>(entry.Description.Size), entry.Description.Data);
sb.Append("%.*s\n", static_cast<int>(entry.Description.Size), entry.Description.Str);
}
else
{
@@ -1056,9 +1056,9 @@ namespace Romeo
printf("Romeo: [%zu/%zu] Symbols done.\n", fileIndex, totalFiles);
// Compare with existing file to decide if we write to disk
Juliet::String existing = ReadFileContent(tempArena, mdFilePath);
Juliet::String newContent = { sb.Buffer, sb.Size };
if (existing.Size == 0 || Juliet::StringCompare(existing, newContent) != 0)
String existing = ReadFileContent(tempArena, mdFilePath);
String newContent = { sb.Buffer, sb.Size };
if (existing.Size == 0 || StringCompare(existing, newContent) != 0)
{
FILE* mdFile = nullptr;
if (fopen_s(&mdFile, mdFilePath, "wb") == 0 && mdFile)
@@ -1078,8 +1078,8 @@ namespace Romeo
printf("Rome: Done processing batch\n");
Juliet::ArenaRelease(aiArena);
Juliet::ArenaRelease(tempArena);
ArenaRelease(aiArena);
ArenaRelease(tempArena);
fclose(overviewFile);
}
}
Romeo/src/MarkdownGenerator.h
+2 -2
View File
@@ -1,7 +1,7 @@
#pragma once
#pragma once
#include "Database.h"
namespace Romeo
{
void MD_GenerateDocumentation(Database& db, const Juliet::String& workspaceRoot, const Juliet::String& docsDir);
void MD_GenerateDocumentation(Database& db, const String& workspaceRoot, const String& docsDir);
}
Romeo/src/main.cpp
+18 -18
View File
@@ -22,19 +22,19 @@
#define ROMEO_WM_TRAYICON (WM_USER + 1)
static Romeo::Database G_Db;
static Juliet::Arena* G_ScratchArena = nullptr;
static Juliet::String G_WorkspaceRoot;
static Juliet::String G_DocsDir;
static Juliet::String G_DbFilePath;
static Arena* G_ScratchArena = nullptr;
static String G_WorkspaceRoot;
static String G_DocsDir;
static String G_DbFilePath;
static Juliet::String GetWorkspaceRoot(Juliet::Arena* arena)
static String GetWorkspaceRoot(Arena* arena)
{
Assert(arena != nullptr);
Juliet::String base = Juliet::GetBasePath();
String base = GetBasePath();
// Copy to arena so we can safely modify it
char* buf = Juliet::ArenaPushArray<char>(arena, base.Size + 1 JULIET_DEBUG_PARAM("WorkspaceRootPath"));
memcpy(buf, base.Data, base.Size);
char* buf = ArenaPushArray<char>(arena, base.Size + 1 JULIET_DEBUG_PARAM("WorkspaceRootPath"));
memcpy(buf, base.Str, base.Size);
buf[base.Size] = '\0';
// Normalize slashes
@@ -205,8 +205,8 @@ static void MonitorThreadProc()
OutputDebugStringA("Romeo Monitor: Change detected, updating...\n");
{
Juliet::LockGuard lock(G_Db.Mutex);
Juliet::ArenaClear(G_ScratchArena);
LockGuard lock(G_Db.Mutex);
ArenaClear(G_ScratchArena);
Romeo::DB_ScanWorkspace(G_Db, G_ScratchArena, G_WorkspaceRoot);
@@ -413,11 +413,11 @@ int JulietMain(int argc, wchar_t** argv)
}
}
Juliet::ArenaParams params{};
Juliet::Arena* mainArena = Juliet::ArenaAllocate(params JULIET_DEBUG_PARAM("RomeoMainArena"));
ArenaParams params{};
Arena* mainArena = ArenaAllocate(params);
Assert(mainArena != nullptr);
G_ScratchArena = Juliet::ArenaAllocate(params JULIET_DEBUG_PARAM("RomeoScratchArena"));
G_ScratchArena = ArenaAllocate(params);
Assert(G_ScratchArena != nullptr);
printf("Arena Allocated! Pointer: %p\n", static_cast<void*>(mainArena));
@@ -426,11 +426,11 @@ int JulietMain(int argc, wchar_t** argv)
char docsDirBuf[512];
snprintf(docsDirBuf, sizeof(docsDirBuf), "%s\\Romeo\\docs", CStr(G_WorkspaceRoot));
G_DocsDir = Juliet::StringCopy(mainArena, Juliet::WrapString(docsDirBuf));
G_DocsDir = StringCopy(mainArena, WrapString(docsDirBuf));
char dbFilePathBuf[512];
snprintf(dbFilePathBuf, sizeof(dbFilePathBuf), "%s\\Romeo\\docs\\romeo.db", CStr(G_WorkspaceRoot));
G_DbFilePath = Juliet::StringCopy(mainArena, Juliet::WrapString(dbFilePathBuf));
G_DbFilePath = StringCopy(mainArena, WrapString(dbFilePathBuf));
Romeo::DB_Init(G_Db, mainArena);
@@ -443,7 +443,7 @@ int JulietMain(int argc, wchar_t** argv)
}
{
Juliet::LockGuard lock(G_Db.Mutex);
LockGuard lock(G_Db.Mutex);
if (!forceRegenerate)
{
Romeo::DB_Load(G_Db, G_DbFilePath);
@@ -559,8 +559,8 @@ int JulietMain(int argc, wchar_t** argv)
G_OllamaJobHandle = nullptr;
}
Juliet::ArenaRelease(mainArena);
Juliet::ArenaRelease(G_ScratchArena);
ArenaRelease(mainArena);
ArenaRelease(G_ScratchArena);
CloseHandle(hMutex);