yyc12345/SuperScriptMaterializer
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor: migrate old code

Browse Source
This commit is contained in:
yyc12345
2024-08-02 17:04:37 +08:00
parent 6736bfbde5
commit 4ee11c29c9
18 changed files with 655 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
materializer/CMakeLists.txt
View File

@@ -16,7 +16,7 @@ PRIVATE
PluginMain.cpp
StandaloneMain.cpp
# Exporter
ExportContext.cpp
ExportDocument.cpp
ExportEnvironment.cpp
ExportScript.cpp
# Utilities
@@ -38,9 +38,7 @@ FILES
PluginMain.hpp
StandaloneMain.hpp
# Exporter
ExportContext.hpp
ExportEnvironment.hpp
ExportScript.hpp
ExportCore.hpp
# Utilities
Utilities.hpp
Database.hpp
@@ -70,7 +68,7 @@ PROPERTIES
CXX_STANDARD_REQUIRED 17
CXX_EXTENSION OFF
)
# Setup MFC use
# Setup MFC used in shared library
set_target_properties(VSWMaterializer
PROPERTIES
CMAKE_MFC_FLAG 2

110
materializer/DataTypes.hpp
View File

@@ -1,10 +1,11 @@
#pragma once
#include "stdafx.hpp"
#include "GenericDataTypes.hpp"
namespace VSW::Materializer::DataTypes {
namespace Script {
struct Table_script {
CK_ID thisobj;
std::string host_name;
@@ -73,10 +74,10 @@ namespace VSW::Materializer::DataTypes {
// additional field
CK_ID input_obj;
bLinkInputOutputType input_type;
VSW::DataTypes::BehaviorLinkIOType input_type;
int input_index;
CK_ID output_obj;
bLinkInputOutputType output_type;
VSW::DataTypes::BehaviorLinkIOType output_type;
int output_index;
};
@@ -103,11 +104,11 @@ namespace VSW::Materializer::DataTypes {
//additional field
CK_ID input_obj;
pLinkInputOutputType input_type;
VSW::DataTypes::ParameterLinkIOType input_type;
BOOL input_is_bb;
int input_index;
CK_ID output_obj;
pLinkInputOutputType output_type;
VSW::DataTypes::ParameterLinkIOType output_type;
BOOL output_is_bb;
int output_index;
};
@@ -133,9 +134,37 @@ namespace VSW::Materializer::DataTypes {
CK_ID parent;
};
class DataCache {
public:
DataCache() :
script(), behavior(),
bIn(), bOut(), bLink(),
pOper(),
pIn(), pOut(), pLocal(), pAttr(), pTarget(), pLink(),
eLink(),
data() {}
~DataCache() {}
public:
Table_script script;
Table_behavior behavior;
Table_bIn bIn;
Table_bOut bOut;
Table_pIn pIn;
Table_pOut pOut;
Table_bLink bLink;
Table_pLocal pLocal;
Table_pAttr pAttr;
Table_pLink pLink;
Table_pOper pOper;
Table_eLink eLink;
Table_pTarget pTarget;
Table_data data;
};
}
namespace Context {
namespace Document {
struct Table_msg {
CKMessageType index;
@@ -149,39 +178,49 @@ namespace VSW::Materializer::DataTypes {
std::string classtype;
};
class DataCache {
public:
DataCache() : msg(), obj() {}
~DataCache() {}
public:
Table_msg msg;
Table_obj obj;
};
}
namespace Environment {
struct Table_op {
CK_PARAMETEROPERATION funcPtr;
std::string in1_guid;
std::string in2_guid;
std::string out_guid;
std::string op_guid;
std::string func_ptr;
int64_t in1_guid;
int64_t in2_guid;
int64_t out_guid;
int64_t op_guid;
std::string op_name;
CKOperationType op_code;
};
struct Table_param {
CKParameterType index;
std::string guid;
std::string derived_from;
int64_t guid;
int64_t derived_from;
std::string type_name;
int default_size;
CK_PARAMETERCREATEDEFAULTFUNCTION func_CreateDefault;
CK_PARAMETERDELETEFUNCTION func_Delete;
CK_PARAMETERSAVELOADFUNCTION func_SaveLoad;
CK_PARAMETERCHECKFUNCTION func_Check;
CK_PARAMETERCOPYFUNCTION func_Copy;
CK_PARAMETERSTRINGFUNCTION func_String;
CK_PARAMETERUICREATORFUNCTION func_UICreator;
std::string func_CreateDefault;
std::string func_Delete;
std::string func_SaveLoad;
std::string func_Check;
std::string func_Copy;
std::string func_String;
std::string func_UICreator;
int creator_dll_index;
int creator_plugin_index;
CKDWORD dw_param;
CKDWORD dw_flags;
CKDWORD cid;
std::string saver_manager;
int64_t saver_manager;
};
struct Table_attr {
@@ -201,24 +240,43 @@ namespace VSW::Materializer::DataTypes {
int plugin_index;
std::string category;
CKBOOL active;
std::string guid;
int64_t guid;
std::string desc;
std::string author;
std::string summary;
DWORD version;
CK_INITINSTANCEFCT func_init;
CK_EXITINSTANCEFCT func_exit;
std::string func_init;
std::string func_exit;
};
#if defined(VIRTOOLS_21)
using GenericVarType_t = int;
#else
using GenericVarType_t = CKVariableManager::Variable::Type;
#endif
struct Table_variable {
std::string name;
std::string desciption;
XWORD flags;
UNIVERSAL_VAR_TYPE type;
GenericVarType_t type;
std::string representation;
std::string data;
};
class DataCache {
public:
DataCache() :
op(), param(), attr(), plugin(), variable() {}
~DataCache() {}
public:
Table_op op;
Table_param param;
Table_attr attr;
Table_plugin plugin;
Table_variable variable;
};
}
}

263
materializer/Database.cpp
View File

@@ -1,5 +1,6 @@
#include "Database.hpp"
#include <stdexcept>
#include <type_traits>
namespace VSW::Materializer::Database {
@@ -10,6 +11,28 @@ namespace VSW::Materializer::Database {
if (errcode != SQLITE_OK) return false;
#define END_SAFE_SQL_EXEC }
/// @brief
/// Check database connection first.
/// Create index variables for sqlite prepared statement binding use.
/// Fetch and reset prepared statement
#define BEGIN_WRITER(stmt_str) if (!this->IsValid()) throw std::runtime_error("write on disconnected database."); \
int argument_index = 1; \
sqlite3_stmt* stmt = GetStmt(stmt_str); \
sqlite3_reset(stmt);
/// @brief Wrapper of binding function calling.
#define WRITER_BIND(eval) if ((eval) != SQLITE_OK) goto failed;
/// @brief Get auto incresement index during binding.
#define WRITER_INDEX (argument_index++)
/// @brief Get prepared statement during binding.
#define WRITER_STMT (stmt)
/// @brief
/// Sumbit binded prepared statement.
/// Binding error process.
#define END_WRITER if (sqlite3_step(stmt) == SQLITE_OK) return; \
failed: throw std::runtime_error("fail to bind value for prepared statement.");
#define REVEAL_ENUM(enum_val) static_cast<std::underlying_type_t<decltype(enum_val)>>(enum_val)
#pragma endregion
#pragma region Abstract Database
@@ -153,16 +176,159 @@ if (errcode != SQLITE_OK) return false;
return true;
}
void ScriptDatabase::Write(const DataTypes::Script::Table_script& data) {
BEGIN_WRITER("INSERT INTO [script] VALUES (?, ?, ?, ?)");
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.thisobj));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.host_name.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.index));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.behavior));
END_WRITER;
}
void ScriptDatabase::Write(const DataTypes::Script::Table_behavior& data) {
BEGIN_WRITER("INSERT INTO [script_behavior] VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.thisobj));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.type));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.proto_name.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.proto_guid.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.flags));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.priority));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.version));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.pin_count.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
END_WRITER;
}
void ScriptDatabase::Write(const DataTypes::Script::Table_bIn& data) {
BEGIN_WRITER("INSERT INTO [script_bIn] VALUES (?, ?, ?, ?)");
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.thisobj));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.index));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
END_WRITER;
}
void ScriptDatabase::Write(const DataTypes::Script::Table_bOut& data) {
BEGIN_WRITER("INSERT INTO [script_bOut] VALUES (?, ?, ?, ?)");
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.thisobj));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.index));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
END_WRITER;
}
void ScriptDatabase::Write(const DataTypes::Script::Table_pIn& data) {
BEGIN_WRITER("INSERT INTO [script_pIn] VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.thisobj));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.index));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type_guid.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.direct_source));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.shared_source));
END_WRITER;
}
void ScriptDatabase::Write(const DataTypes::Script::Table_pOut& data) {
BEGIN_WRITER("INSERT INTO [script_pOut] VALUES (?, ?, ?, ?, ?, ?)");
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.thisobj));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.index));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type_guid.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
END_WRITER;
}
void ScriptDatabase::Write(const DataTypes::Script::Table_bLink& data) {
BEGIN_WRITER("INSERT INTO [script_bLink] VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.input));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.output));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.delay));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.input_obj));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, REVEAL_ENUM(data.input_type)));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.input_index));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.output_obj));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, REVEAL_ENUM(data.output_type)));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.output_index));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
END_WRITER;
}
void ScriptDatabase::Write(const DataTypes::Script::Table_pLocal& data) {
BEGIN_WRITER("INSERT INTO [script_pLocal] VALUES (?, ?, ?, ?, ?, ?)");
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.thisobj));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type_guid.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.is_setting));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
END_WRITER;
}
void ScriptDatabase::Write(const DataTypes::Script::Table_pAttr& data) {
BEGIN_WRITER("INSERT INTO [script_pAttr] VALUES (?, ?, ?, ?)");
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.thisobj));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type_guid.c_str(), -1, SQLITE_TRANSIENT));
END_WRITER;
}
void ScriptDatabase::Write(const DataTypes::Script::Table_pLink& data) {
BEGIN_WRITER("INSERT INTO [script_pLink] VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.input));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.output));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.input_obj));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, REVEAL_ENUM(data.input_type)));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.input_is_bb));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.input_index));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.output_obj));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, REVEAL_ENUM(data.output_type)));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.output_is_bb));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.output_index));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
END_WRITER;
}
void ScriptDatabase::Write(const DataTypes::Script::Table_pOper& data) {
BEGIN_WRITER("INSERT INTO [script_pOper] VALUES (?, ?, ?, ?)");
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.thisobj));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.op.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.op_guid.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
END_WRITER;
}
void ScriptDatabase::Write(const DataTypes::Script::Table_eLink& data) {
BEGIN_WRITER("INSERT INTO [script_eLink] VALUES (?, ?, ?, ?, ?)");
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.export_obj));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.internal_obj));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.is_in));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.index));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
END_WRITER;
}
void ScriptDatabase::Write(const DataTypes::Script::Table_pTarget& data) {
BEGIN_WRITER("INSERT INTO [script_pTarget] VALUES (?, ?, ?, ?, ?, ?, ?)");
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.thisobj));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type_guid.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.direct_source));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.shared_source));
END_WRITER;
}
void ScriptDatabase::Write(const DataTypes::Script::Table_data& data) {
BEGIN_WRITER("INSERT INTO [data] VALUES (?, ?, ?)");
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.field.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.data.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
END_WRITER;
}
#pragma endregion
#pragma region Context Database
#pragma region Document Database
ContextDatabase::ContextDatabase(const YYCC::yycc_u8string_view& file) :
DocumentDatabase::DocumentDatabase(const YYCC::yycc_u8string_view& file) :
AbstractDatabase(file) {}
ContextDatabase::~ContextDatabase() {}
DocumentDatabase::~DocumentDatabase() {}
bool ContextDatabase::PostOpen() {
bool DocumentDatabase::PostOpen() {
// initialize table
BEGIN_SAFE_SQL_EXEC;
SAFE_SQL_EXEC("begin;");
@@ -176,11 +342,26 @@ if (errcode != SQLITE_OK) return false;
return true;
}
bool ContextDatabase::PreClose() {
bool DocumentDatabase::PreClose() {
// do nothing
return true;
}
void DocumentDatabase::Write(const DataTypes::Document::Table_msg& data) {
BEGIN_WRITER("INSERT INTO [msg] VALUES (?, ?)");
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.index));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
END_WRITER;
}
void DocumentDatabase::Write(const DataTypes::Document::Table_obj& data) {
BEGIN_WRITER("INSERT INTO [obj] VALUES (?, ?, ?, ?)");
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.id));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.classid));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.classtype.c_str(), -1, SQLITE_TRANSIENT));
END_WRITER;
}
#pragma endregion
#pragma region Environment Database
@@ -212,6 +393,78 @@ if (errcode != SQLITE_OK) return false;
return true;
}
void EnvironmentDatabase::Write(const DataTypes::Environment::Table_op& data) {
BEGIN_WRITER("INSERT INTO [op] VALUES (?, ?, ?, ?, ?, ?, ?)");
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.func_ptr.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int64(WRITER_STMT, WRITER_INDEX, data.in1_guid));
WRITER_BIND(sqlite3_bind_int64(WRITER_STMT, WRITER_INDEX, data.in2_guid));
WRITER_BIND(sqlite3_bind_int64(WRITER_STMT, WRITER_INDEX, data.out_guid));
WRITER_BIND(sqlite3_bind_int64(WRITER_STMT, WRITER_INDEX, data.op_guid));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.op_name.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.op_code));
END_WRITER;
}
void EnvironmentDatabase::Write(const DataTypes::Environment::Table_param& data) {
BEGIN_WRITER("INSERT INTO [param] VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.index));
WRITER_BIND(sqlite3_bind_int64(WRITER_STMT, WRITER_INDEX, data.guid));
WRITER_BIND(sqlite3_bind_int64(WRITER_STMT, WRITER_INDEX, data.derived_from));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type_name.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.default_size));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.func_CreateDefault.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.func_Delete.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.func_SaveLoad.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.func_Check.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.func_Copy.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.func_String.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.func_UICreator.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.creator_dll_index));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.creator_plugin_index));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.dw_param));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.dw_flags));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.cid));
WRITER_BIND(sqlite3_bind_int64(WRITER_STMT, WRITER_INDEX, data.saver_manager));
END_WRITER;
}
void EnvironmentDatabase::Write(const DataTypes::Environment::Table_attr& data) {
BEGIN_WRITER("INSERT INTO [attr] VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.index));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.category_index));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.category_name.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.flags));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.param_index));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.compatible_classid));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.default_value.c_str(), -1, SQLITE_TRANSIENT));
END_WRITER;
}
void EnvironmentDatabase::Write(const DataTypes::Environment::Table_plugin& data) {
BEGIN_WRITER("INSERT INTO [plugin] VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.dll_index));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.dll_name.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.plugin_index));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.category.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.active));
WRITER_BIND(sqlite3_bind_int64(WRITER_STMT, WRITER_INDEX, data.guid));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.desc.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.author.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.summary.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.version));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.func_init.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.func_exit.c_str(), -1, SQLITE_TRANSIENT));
END_WRITER;
}
void EnvironmentDatabase::Write(const DataTypes::Environment::Table_variable& data) {
BEGIN_WRITER("INSERT INTO [variable] VALUES (?, ?, ?, ?, ?, ?)");
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.desciption.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.flags));
WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.type));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.representation.c_str(), -1, SQLITE_TRANSIENT));
WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.data.c_str(), -1, SQLITE_TRANSIENT));
END_WRITER;
}
#pragma endregion
}

43
materializer/Database.hpp
View File

@@ -1,5 +1,6 @@
#pragma once
#include "stdafx.hpp"
#include "DataTypes.hpp"
#include <sqlite3.h>
#include <map>
@@ -55,24 +56,38 @@ namespace VSW::Materializer::Database {
virtual bool PreClose() override;
public:
void Write(const DataTypes::Script::Table_script& data);
void Write(const DataTypes::Script::Table_behavior& data);
void Write(const DataTypes::Script::Table_bIn& data);
void Write(const DataTypes::Script::Table_bOut& data);
void Write(const DataTypes::Script::Table_pIn& data);
void Write(const DataTypes::Script::Table_pOut& data);
void Write(const DataTypes::Script::Table_bLink& data);
void Write(const DataTypes::Script::Table_pLocal& data);
void Write(const DataTypes::Script::Table_pAttr& data);
void Write(const DataTypes::Script::Table_pLink& data);
void Write(const DataTypes::Script::Table_pOper& data);
void Write(const DataTypes::Script::Table_eLink& data);
void Write(const DataTypes::Script::Table_pTarget& data);
void Write(const DataTypes::Script::Table_data& data);
};
class ContextDatabase : public AbstractDatabase {
class DocumentDatabase : public AbstractDatabase {
public:
ContextDatabase(const YYCC::yycc_u8string_view& file);
virtual ~ContextDatabase();
ContextDatabase(const ContextDatabase&) = delete;
ContextDatabase& operator=(const ContextDatabase&) = delete;
ContextDatabase(ContextDatabase&&) = delete;
ContextDatabase& operator=(ContextDatabase&&) = delete;
DocumentDatabase(const YYCC::yycc_u8string_view& file);
virtual ~DocumentDatabase();
DocumentDatabase(const DocumentDatabase&) = delete;
DocumentDatabase& operator=(const DocumentDatabase&) = delete;
DocumentDatabase(DocumentDatabase&&) = delete;
DocumentDatabase& operator=(DocumentDatabase&&) = delete;
protected:
virtual bool PostOpen() override;
virtual bool PreClose() override;
public:
void Write(const DataTypes::Document::Table_msg& data);
void Write(const DataTypes::Document::Table_obj& data);
};
class EnvironmentDatabase : public AbstractDatabase {
@@ -83,13 +98,17 @@ namespace VSW::Materializer::Database {
EnvironmentDatabase& operator=(const EnvironmentDatabase&) = delete;
EnvironmentDatabase(EnvironmentDatabase&&) = delete;
EnvironmentDatabase& operator=(EnvironmentDatabase&&) = delete;
protected:
virtual bool PostOpen() override;
virtual bool PreClose() override;
public:
void Write(const DataTypes::Environment::Table_op& data);
void Write(const DataTypes::Environment::Table_param& data);
void Write(const DataTypes::Environment::Table_attr& data);
void Write(const DataTypes::Environment::Table_plugin& data);
void Write(const DataTypes::Environment::Table_variable& data);
};
}

5
materializer/ExportContext.cpp
View File

@@ -1,5 +0,0 @@
#include "ExportContext.hpp"
namespace VSW::Materializer::ExportContext {
}

6
materializer/ExportContext.hpp
View File

@@ -1,6 +0,0 @@
#pragma once
#include "stdafx.hpp"
namespace VSW::Materializer::ExportContext {
}

18
materializer/ExportCore.hpp Normal file
View File

@@ -0,0 +1,18 @@
#pragma once
#include "stdafx.hpp"
namespace YYCC::Materializer {
namespace ExportScript {
void Export(CKContext* ctx, YYCC::yycc_u8string_view& db_path);
}
namespace ExportDocument {
void Export(CKContext* ctx, YYCC::yycc_u8string_view& db_path);
}
namespace ExportEnvironment {
void Export(CKContext* ctx, YYCC::yycc_u8string_view& db_path);
}
}

12
materializer/ExportDocument.cpp Normal file
View File

@@ -0,0 +1,12 @@
#include "ExportCore.hpp"
namespace VSW::Materializer::ExportDocument {
void Export(CKContext* ctx, YYCC::yycc_u8string_view& db_path) {
}
}

169
materializer/ExportEnvironment.cpp
View File

@@ -1,5 +1,172 @@
#include "ExportEnvironment.hpp"
#include "ExportCore.hpp"
#include "Database.hpp"
#include "DataTypes.hpp"
#include "Utilities.hpp"
#include <vector>
namespace VSW::Materializer::ExportEnvironment {
struct ExportContext {
ExportContext(YYCC::yycc_u8string_view& db_path) :
db(db_path), cache() {}
Database::EnvironmentDatabase db;
DataTypes::Environment::DataCache cache;
};
static void IterateParameterOperation(ExportContext& expctx, CKParameterManager* param_mgr) {
// prepare variables
std::vector<CKOperationDesc> op_list;
CKGUID guid;
// get the count of all supported paramter operations and iterate it.
int count = param_mgr->GetParameterOperationCount();
int listCount = 0, cacheListCount = 0;
for (int i = 0; i < count; i++) {
// fill the shared data part.
expctx.cache.op.op_code = i;
guid = param_mgr->OperationCodeToGuid(i);
Utilities::CopyGuid(expctx.cache.op.op_guid, guid);
expctx.cache.op.op_name = param_mgr->OperationCodeToName(i);
// get all sub-operation of this parameter operation.
// each sub-operation can have different in out parameter type
// and they are just grouped into the same parameter operation name.
int op_list_count = param_mgr->GetAvailableOperationsDesc(guid, nullptr, nullptr, nullptr, nullptr);
op_list.resize(static_cast<size_t>(op_list_count));
param_mgr->GetAvailableOperationsDesc(guid, nullptr, nullptr, nullptr, op_list.data());
for (const auto& op : op_list) {
Utilities::CopyGuid(expctx.cache.op.in1_guid, op.P1Guid);
Utilities::CopyGuid(expctx.cache.op.in2_guid, op.P2Guid);
Utilities::CopyGuid(expctx.cache.op.out_guid, op.ResGuid);
expctx.cache.op.func_ptr = Utilities::RelativeAddress(op.Fct);
expctx.db.Write(expctx.cache.op);
}
}
}
static void IterateParameter(ExportContext& expctx, CKParameterManager* param_mgr) {
// prepare variables
CKParameterTypeDesc* desc = nullptr;
// get the count of all paramter types and iterate it.
int count = param_mgr->GetParameterTypesCount();
for (int i = 0; i < count; i++) {
desc = param_mgr->GetParameterTypeDescription(i);
expctx.cache.param.index = desc->Index;
Utilities::CopyGuid(expctx.cache.param.guid, desc->Guid);
Utilities::CopyGuid(expctx.cache.param.derived_from, desc->DerivedFrom);
expctx.cache.param.type_name = desc->TypeName.CStr();
expctx.cache.param.default_size = desc->DefaultSize;
expctx.cache.param.func_CreateDefault = Utilities::RelativeAddress(desc->CreateDefaultFunction);
expctx.cache.param.func_Delete = Utilities::RelativeAddress(desc->DeleteFunction);
expctx.cache.param.func_SaveLoad = Utilities::RelativeAddress(desc->SaveLoadFunction);
expctx.cache.param.func_Check = Utilities::RelativeAddress(desc->CheckFunction);
expctx.cache.param.func_Copy = Utilities::RelativeAddress(desc->CopyFunction);
expctx.cache.param.func_String = Utilities::RelativeAddress(desc->StringFunction);
expctx.cache.param.func_UICreator = Utilities::RelativeAddress(desc->UICreatorFunction);
CKPluginEntry* plugin_entry = desc->CreatorDll;
if (plugin_entry != nullptr) {
expctx.cache.param.creator_dll_index = plugin_entry->m_PluginDllIndex;
expctx.cache.param.creator_plugin_index = plugin_entry->m_PositionInDll;
} else {
expctx.cache.param.creator_dll_index = -1;
expctx.cache.param.creator_plugin_index = -1;
}
expctx.cache.param.dw_param = desc->dwParam;
expctx.cache.param.dw_flags = desc->dwFlags;
expctx.cache.param.cid = desc->Cid;
Utilities::CopyGuid(expctx.cache.param.saver_manager, desc->Saver_Manager);
expctx.db.Write(expctx.cache.param);
}
}
static void IterateAttribute(ExportContext& expctx, CKAttributeManager* attr_mgr) {
// get the count of all attributes and iterate it.
int count = attr_mgr->GetAttributeCount();
for (int i = 0; i < count; i++) {
expctx.cache.attr.index = i;
expctx.cache.attr.name = attr_mgr->GetAttributeNameByType(i);
expctx.cache.attr.category_index = attr_mgr->GetAttributeCategoryIndex(i);
Utilities::CopyCKString(expctx.cache.attr.category_name, attr_mgr->GetAttributeCategory(i));
expctx.cache.attr.flags = attr_mgr->GetAttributeFlags(i);
expctx.cache.attr.param_index = attr_mgr->GetAttributeParameterType(i);
expctx.cache.attr.compatible_classid = attr_mgr->GetAttributeCompatibleClassId(i);
Utilities::CopyCKString(expctx.cache.attr.default_value, attr_mgr->GetAttributeDefaultValue(i));
expctx.db.Write(expctx.cache.attr);
}
}
static void IteratePlugin(ExportContext& expctx, CKPluginManager* plugin_mgr) {
// get category count and iterate them
int category_count = plugin_mgr->GetCategoryCount();
for (int i = 0; i < category_count; ++i) {
// get category name and set it
expctx.cache.plugin.category = plugin_mgr->GetCategoryName(i);
// iterate plugin within this category
int plugin_count = plugin_mgr->GetPluginCount(i);
for (int j = 0; j < plugin_count; j++) {
CKPluginEntry* plugin_entry = plugin_mgr->GetPluginInfo(i, j);
CKPluginInfo* plugin_info = &(plugin_entry->m_PluginInfo);
CKPluginDll* plugin_dll = plugin_mgr->GetPluginDllInfo(plugin_entry->m_PluginDllIndex);
expctx.cache.plugin.dll_index = plugin_entry->m_PluginDllIndex;
expctx.cache.plugin.dll_name = plugin_dll->m_DllFileName.CStr();
expctx.cache.plugin.plugin_index = plugin_entry->m_PositionInDll;
expctx.cache.plugin.active = plugin_entry->m_Active;
Utilities::CopyGuid(expctx.cache.plugin.guid, plugin_info->m_GUID);
expctx.cache.plugin.desc = plugin_info->m_Description.CStr();
expctx.cache.plugin.author = plugin_info->m_Author.CStr();
expctx.cache.plugin.summary = plugin_info->m_Summary.CStr();
expctx.cache.plugin.version = plugin_info->m_Version;
expctx.cache.plugin.func_init = Utilities::RelativeAddress(plugin_info->m_InitInstanceFct);
expctx.cache.plugin.func_exit = Utilities::RelativeAddress(plugin_info->m_ExitInstanceFct);
expctx.db.Write(expctx.cache.plugin);
}
}
}
#if !defined(VIRTOOLS_21)
static void IterateVariable(ExportContext& expctx, CKVariableManager* var_mgr) {
// prepare variables
CKVariableManager::Variable* varobj = nullptr;
XString xstring_cache;
for (CKVariableManager::Iterator it = var_mgr->GetVariableIterator(); !it.End(); it++) {
varobj = it.GetVariable();
expctx.cache.variable.name = it.GetName();
Utilities::CopyCKString(expctx.cache.variable.desciption, varobj->GetDescription());
expctx.cache.variable.flags = varobj->GetFlags();
expctx.cache.variable.type = varobj->GetType();
Utilities::CopyCKString(expctx.cache.variable.representation, varobj->GetRepresentation());
varobj->GetStringValue(xstring_cache);
expctx.cache.variable.data = xstring_cache.CStr();
expctx.db.Write(expctx.cache.variable);
}
}
#endif
void Export(CKContext* ctx, YYCC::yycc_u8string_view& db_path) {
// create database and data cache in context
ExportContext expctx(db_path);
// export environment one by one
IterateParameterOperation(expctx, ctx->GetParameterManager());
IterateParameter(expctx, ctx->GetParameterManager());
IterateAttribute(expctx, ctx->GetAttributeManager());
IteratePlugin(expctx, CKGetPluginManager());
#if !defined(VIRTOOLS_21)
IterateVariable(expctx, ctx->GetVariableManager());
#endif
}
}

6
materializer/ExportEnvironment.hpp
View File

@@ -1,6 +0,0 @@
#pragma once
#include "stdafx.hpp"
namespace VSW::Materializer::ExportEnvironment {
}

9
materializer/ExportScript.cpp
View File

@@ -1,5 +1,12 @@
#include "ExportScript.hpp"
#include "ExportCore.hpp"
namespace VSW::Materializer::ExportScript {
void Export(CKContext* ctx, YYCC::yycc_u8string_view& db_path) {
}
}

6
materializer/ExportScript.hpp
View File

@@ -1,6 +0,0 @@
#pragma once
#include "stdafx.hpp"
namespace VSW::Materializer::ExportScript {
}

5
materializer/PluginMain.cpp
View File

@@ -1,4 +1,5 @@
#include "PluginMain.hpp"
#include "ExportCore.hpp"
namespace VSW::Materializer::PluginMain {
@@ -62,8 +63,8 @@ namespace VSW::Materializer::PluginMain {
static void UpdateMenu() {
g_Plugininterface->ClearPluginMenu(g_MainMenu);
g_Plugininterface->AddPluginMenuItem(g_MainMenu, 0, "Export Scripts");
g_Plugininterface->AddPluginMenuItem(g_MainMenu, 1, "Export Context");
g_Plugininterface->AddPluginMenuItem(g_MainMenu, 0, "Export Script");
g_Plugininterface->AddPluginMenuItem(g_MainMenu, 1, "Export Document");
g_Plugininterface->AddPluginMenuItem(g_MainMenu, 2, "Export Environment");
g_Plugininterface->AddPluginMenuItem(g_MainMenu, -1, NULL, TRUE);
g_Plugininterface->AddPluginMenuItem(g_MainMenu, 3, "Report Bug");

51
materializer/Utilities.cpp
View File

@@ -2,4 +2,55 @@
namespace VSW::Materializer::Utilities {
std::string RelativeAddress(const void* absolute_addr) {
// prepare return value
std::string ret("<error>");
// If address is nullptr, return directly
if (absolute_addr == nullptr) {
ret = "<nullptr>";
return ret;
}
// Get the module handle which given function address belongs to
// Reference: https://stackoverflow.com/questions/557081/how-do-i-get-the-hmodule-for-the-currently-executing-code
HMODULE hModule = NULL;
GetModuleHandleExW(
GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, // get address and do not inc ref counter.
(LPCWSTR)absolute_addr,
&hModule);
if (hModule == NULL)
return ret;
// Get full path to module
YYCC::yycc_u8string u8_module_path;
if (!YYCC::WinFctHelper::GetModuleFileName(hModule, u8_module_path))
return ret;
// Then get its file name part
auto module_path = YYCC::FsPathPatch::FromUTF8Path(u8_module_path.c_str());
auto u8_module_name = YYCC::FsPathPatch::ToUTF8Path(module_path.filename());
// Get the base address of current module
// HMODULE is the base address of loaded module
// Reference: https://stackoverflow.com/questions/4298331/exe-or-dll-image-base-address
uintptr_t relative_addr = reinterpret_cast<uintptr_t>(absolute_addr) - reinterpret_cast<uintptr_t>(hModule);
// get final result
auto u8_ret = YYCC::StringHelper::Printf(YYCC_U8("%s+%" PRI_XPTR_LEFT_PADDING PRIXPTR), u8_module_name.c_str(), relative_addr);
ret = YYCC::EncodingHelper::ToOrdinaryView(u8_ret);
return ret;
}
void CopyGuid(int64_t& dst, const CKGUID& src) {
// todo: use template argument to implement this to improve performance
if (sizeof(dst) != sizeof(src))
throw std::invalid_argument("CKGUID size error");
std::memcpy(&dst, &src, sizeof(int64_t));
}
void CopyCKString(std::string& storage, const char* str) {
if (str == nullptr) storage = "<unamed>";
else storage = str;
}
}

14
materializer/Utilities.hpp
View File

@@ -2,5 +2,19 @@
#include "stdafx.hpp"
namespace VSW::Materializer::Utilities {
/// @brief The value representing a invalid CK_ID.
constexpr CK_ID INVALID_CK_ID = static_cast<CK_ID>(-1);
/**
* @brief Get relative address from given absolute address
* @details This function is used when exporting function pointer into database.
* @param[in] absolute_addr The absolute address
* @return Module based relative address like \c xxx.dll+0x00000000.
*/
std::string RelativeAddress(const void* absolute_addr);
void CopyGuid(int64_t& dst, const CKGUID& src);
void CopyCKString(std::string& storage, const char* str);
}