bool CompileScope(CompileInstance &inst, const mtlChars &input, bool branch)
{
bool result = true;
Scope &scope = PushScope(inst, branch);
scope.parser.SetBuffer(input);
mtlList<mtlChars> m;
while (result && !scope.parser.IsEnd()) {
switch (scope.parser.MatchPart("{%s}%|%w%w(%s){%s}%|if(%s){%s}else{%s}%|if(%s){%s}%|%s;", m, NULL)) {
case 0: // SCOPE
result = CompileScope(inst, m.GetFirst()->GetItem(), false);
break;
case 1: // FUNCTION
result = CompileFunction(inst, m.GetFirst()->GetItem(), m.GetFirst()->GetNext()->GetItem(), m.GetFirst()->GetNext()->GetNext()->GetItem(), m.GetFirst()->GetNext()->GetNext()->GetNext()->GetItem());
break;
case 2: // CONDITION
result = CompileCondition(inst, m.GetFirst()->GetNext()->GetItem(), m.GetFirst()->GetNext()->GetNext()->GetItem(), "");
break;
case 3: // CONDITION
result = CompileCondition(inst, m.GetFirst()->GetNext()->GetItem(), m.GetFirst()->GetNext()->GetNext()->GetItem(), m.GetFirst()->GetNext()->GetNext()->GetNext()->GetItem());
break;
case 4: // STATEMENT
result = CompileStatement(inst, m.GetFirst()->GetItem());
break;
default:
AddError(inst, "Malformed sequence", input);
return false;
break;
}
}
PopScope(inst);
return result;
}
// Read data
void AppWindow::OnOpen(BMessage *msg) {
entry_ref ref;
BMessage archive;
msg->FindRef("refs", &ref);
BFile file(&ref, B_READ_ONLY);
archive.Unflatten(&file);
Graph *g = (Graph*)Graph::Instantiate(&archive);
if (g != NULL) {
delete view->graph; view->graph = g;
BMenu *menu = data->functions->Menu();
while (menu->RemoveItem((int32)0) != NULL);
Function1 *f;
int i;
if (program->Lock()) {
program->view->SetText(g->GetDefinitions()->GetText());
program->Unlock();
}
MarkColorMenuItem(bg_color, view->graph->bg_color);
MarkColorMenuItem(axes_color, view->graph->axes_color);
ExprList *el = g->GetGraphExprs();
for (i = 0; i < 6; i++)
data->gCtrls[i]->SetText(el->GetText(i));
for (i = 0; i < 5; i++)
data->fCtrls[i]->SetText("");
UpdateGraph();
for (i = 0; NULL != (f = g->GetFunction(i)); i++) {
CompileFunction(f, false);
}
for (i = 0; NULL != (f = g->GetFunction(i)); i++)
AddFunction(f);
OnSelect();
OnUpdate();
} else {
BAlert *a = new BAlert("Open Error", "Could not read file.", "OK");
a->Go();
}
}
// Read all data, parse und evaluate it
bool AppWindow::CheckFunction() {
int i;
UpdateGraph();
for (i = 0; i < 5; i++) {
view->f1->Exprs()->SetText(i, data->fCtrls[i]->Text());
}
view->f1->SetVisible(data->visible->Value());
ColorMenuItem *c = (ColorMenuItem*)data->color->Menu()->FindMarked();
if (c != NULL) view->f1->SetColor(c->GetColor());
BMenuItem *item = data->style->Menu()->FindMarked();
if (item != NULL) view->f1->SetStyle(data->style->Menu()->IndexOf(item));
if (CompileFunction(view->f1, true)) {
statusLine->SetText("ok");
return true;
} else
return false;
}
void Compile(const char* databasePathName, const char* cpuArchName, const char* imageFormatName, const char* outputPath)
{
CPsfVm virtualMachine;
auto subSystem = std::make_shared<Iop::CPsfSubSystem>(false);
virtualMachine.SetSubSystem(subSystem);
Jitter::CCodeGen* codeGen = nullptr;
Jitter::CObjectFile::CPU_ARCH cpuArch = Jitter::CObjectFile::CPU_ARCH_X86;
if(!strcmp(cpuArchName, "x86"))
{
codeGen = new Jitter::CCodeGen_x86_32();
cpuArch = Jitter::CObjectFile::CPU_ARCH_X86;
}
else if(!strcmp(cpuArchName, "arm"))
{
codeGen = new Jitter::CCodeGen_Arm();
cpuArch = Jitter::CObjectFile::CPU_ARCH_ARM;
}
else
{
throw std::runtime_error("Invalid cpu target.");
}
std::unique_ptr<Jitter::CObjectFile> objectFile;
if(!strcmp(imageFormatName, "coff"))
{
objectFile = std::make_unique<Jitter::CCoffObjectFile>(cpuArch);
}
else if(!strcmp(imageFormatName, "macho"))
{
objectFile = std::make_unique<Jitter::CMachoObjectFile>(cpuArch);
}
else
{
throw std::runtime_error("Invalid executable image type (must be coff or macho).");
}
codeGen->RegisterExternalSymbols(objectFile.get());
objectFile->AddExternalSymbol("_MemoryUtils_GetByteProxy", &MemoryUtils_GetByteProxy);
objectFile->AddExternalSymbol("_MemoryUtils_GetHalfProxy", &MemoryUtils_GetHalfProxy);
objectFile->AddExternalSymbol("_MemoryUtils_GetWordProxy", &MemoryUtils_GetWordProxy);
objectFile->AddExternalSymbol("_MemoryUtils_SetByteProxy", &MemoryUtils_SetByteProxy);
objectFile->AddExternalSymbol("_MemoryUtils_SetHalfProxy", &MemoryUtils_SetHalfProxy);
objectFile->AddExternalSymbol("_MemoryUtils_SetWordProxy", &MemoryUtils_SetWordProxy);
objectFile->AddExternalSymbol("_LWL_Proxy", &LWL_Proxy);
objectFile->AddExternalSymbol("_LWR_Proxy", &LWR_Proxy);
objectFile->AddExternalSymbol("_SWL_Proxy", &SWL_Proxy);
objectFile->AddExternalSymbol("_SWR_Proxy", &SWR_Proxy);
filesystem::path databasePath(databasePathName);
auto blocks = GetBlocksFromCache(databasePath);
//Initialize Jitter Service
auto jitter = new CMipsJitter(codeGen);
for(unsigned int i = 0; i < 4; i++)
{
jitter->SetVariableAsConstant(
offsetof(CMIPS, m_State.nGPR[CMIPS::R0].nV[i]),
0
);
}
printf("Got %d blocks to compile.\r\n", blocks.size());
FunctionTable functionTable;
functionTable.reserve(blocks.size());
for(const auto& blockCachePair : blocks)
{
const auto& blockKey = blockCachePair.first;
auto functionName = "aotblock_" + std::to_string(blockKey.crc) + "_" + std::to_string(blockKey.begin) + "_" + std::to_string(blockKey.end);
unsigned int functionSymbolIndex = CompileFunction(virtualMachine, jitter, blockCachePair.second, *objectFile, functionName, blockKey.begin, blockKey.end);
FUNCTION_TABLE_ITEM tableItem = { blockKey, functionSymbolIndex };
functionTable.push_back(tableItem);
}
std::sort(functionTable.begin(), functionTable.end(),
[] (const FUNCTION_TABLE_ITEM& item1, const FUNCTION_TABLE_ITEM& item2)
{
return item1.key < item2.key;
}
);
{
Framework::CMemStream blockTableStream;
Jitter::CObjectFile::INTERNAL_SYMBOL blockTableSymbol;
blockTableSymbol.name = "__aot_firstBlock";
blockTableSymbol.location = Jitter::CObjectFile::INTERNAL_SYMBOL_LOCATION_DATA;
for(const auto& functionTableItem : functionTable)
{
blockTableStream.Write32(functionTableItem.key.crc);
blockTableStream.Write32(functionTableItem.key.begin);
blockTableStream.Write32(functionTableItem.key.end);
{
Jitter::CObjectFile::SYMBOL_REFERENCE ref;
ref.offset = static_cast<uint32>(blockTableStream.Tell());
ref.type = Jitter::CObjectFile::SYMBOL_TYPE_INTERNAL;
ref.symbolIndex = functionTableItem.symbolIndex;
blockTableSymbol.symbolReferences.push_back(ref);
}
blockTableStream.Write32(0);
}
blockTableSymbol.data = std::vector<uint8>(blockTableStream.GetBuffer(), blockTableStream.GetBuffer() + blockTableStream.GetLength());
objectFile->AddInternalSymbol(blockTableSymbol);
}
{
Jitter::CObjectFile::INTERNAL_SYMBOL blockCountSymbol;
blockCountSymbol.name = "__aot_blockCount";
blockCountSymbol.location = Jitter::CObjectFile::INTERNAL_SYMBOL_LOCATION_DATA;
blockCountSymbol.data = std::vector<uint8>(4);
*reinterpret_cast<uint32*>(blockCountSymbol.data.data()) = functionTable.size();
objectFile->AddInternalSymbol(blockCountSymbol);
}
objectFile->Write(Framework::CStdStream(outputPath, "wb"));
}
