DbEngineParameters DatabaseSettingsWidget::getDbEngineParameters() const
{
DbEngineParameters prm;
switch(databaseType())
{
case SQlite:
prm = DbEngineParameters::parametersForSQLiteDefaultFile(databasePath());
break;
case MysqlInternal:
prm = DbEngineParameters::defaultParameters(databaseBackend());
prm.setInternalServerPath(databasePath());
prm.internalServerMysqlServCmd = d->mysqlServerCmdEdit->lineEdit()->text();
prm.internalServerMysqlInitCmd = d->mysqlInitCmdEdit->lineEdit()->text();
break;
default: // MysqlServer
prm.internalServer = false;
prm.databaseType = databaseBackend();
prm.databaseNameCore = d->dbNameCore->text();
prm.databaseNameThumbnails = d->dbNameThumbs->text();
prm.databaseNameFace = d->dbNameFace->text();
prm.connectOptions = d->connectOpts->text();
prm.hostName = d->hostName->text();
prm.port = d->hostPort->text().toInt();
prm.userName = d->userName->text();
prm.password = d->password->text();
break;
}
return prm;
}
void TestApplication::destroy()
{
QVERIFY( controller()->disconnectFromBackend() );
delete m_model; m_model = 0;
delete m_controller; m_controller = 0;
if ( QDir::home().exists( databasePath() ) ) {
const bool result = QDir::home().remove( databasePath() );
QVERIFY( result );
}
}
bool DatabaseSettingsWidget::checkDatabasePath()
{
QString dbFolder = databasePath();
qCDebug(DIGIKAM_DATABASE_LOG) << "Database directory is : " << dbFolder;
if (dbFolder.isEmpty())
{
QMessageBox::information(qApp->activeWindow(), qApp->applicationName(),
i18n("You must select a folder for digiKam to "
"store information and metadata in a database file."));
return false;
}
QDir targetPath(dbFolder);
if (!targetPath.exists())
{
int rc = QMessageBox::question(qApp->activeWindow(), i18n("Create Database Folder?"),
i18n("<p>The folder to put your database in does not seem to exist:</p>"
"<p><b>%1</b></p>"
"Would you like digiKam to create it for you?", dbFolder));
if (rc == QMessageBox::No)
{
return false;
}
if (!targetPath.mkpath(dbFolder))
{
QMessageBox::information(qApp->activeWindow(), i18n("Create Database Folder Failed"),
i18n("<p>digiKam could not create the folder to host your database file.\n"
"Please select a different location.</p>"
"<p><b>%1</b></p>", dbFolder));
return false;
}
}
QFileInfo path(dbFolder);
#ifdef _WIN32
// Work around bug #189168
QTemporaryFile temp;
temp.setFileTemplate(dbFolder + QLatin1String("XXXXXX"));
if (!temp.open())
#else
if (!path.isWritable())
#endif
{
QMessageBox::information(qApp->activeWindow(), i18n("No Database Write Access"),
i18n("<p>You do not seem to have write access "
"for the folder to host the database file.<br/>"
"Please select a different location.</p>"
"<p><b>%1</b></p>", dbFolder));
return false;
}
return true;
}
void DatabaseSettingsWidget::slotDatabasePathEdited()
{
QString newPath = databasePath();
#ifndef _WIN32
if (!newPath.isEmpty() && !QDir::isAbsolutePath(newPath))
{
d->dbPathEdit->lineEdit()->setText(QDir::homePath() + QLatin1Char('/') + QDir::fromNativeSeparators(newPath));
}
#endif
d->dbPathEdit->lineEdit()->setText(QDir::toNativeSeparators(newPath));
}
void LocalStorageDatabaseTracker::didOpenDatabaseWithOrigin(const SecurityOriginData& securityOrigin)
{
addDatabaseWithOriginIdentifier(securityOrigin.databaseIdentifier(), databasePath(securityOrigin));
}
String LocalStorageDatabaseTracker::databasePath(const SecurityOriginData& securityOrigin) const
{
return databasePath(securityOrigin.databaseIdentifier() + ".localstorage");
}
String LocalStorageDatabaseTracker::trackerDatabasePath() const
{
return databasePath("StorageTracker.db");
}
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"));
}
