bool call(const arguments & args_, std::string & result) {
//LOG(INFO) << "Calling [" << args_.as_string(0) << "]";
if (_modules.find(args_.as_string(0)) == _modules.end()) {
return false;
}
result = "";
result.resize(4096);
std::string function_str;
std::vector<std::string> temp = ace::split(args_.get(), ',');
if (temp.size() < 3) {
function_str = temp[1];
} else {
for (int x = 1; x < temp.size(); x++)
function_str = function_str + temp[x] + ",";
}
_modules[args_.as_string(0)].function((char *)result.c_str(), 4096, (const char *)function_str.c_str());
#ifdef _DEBUG
//if (args_.as_string(0) != "fetch_result" && args_.as_string(0) != "ready") {
// LOG(INFO) << "Called [" << args_.as_string(0) << "], with {" << function_str << "} result={" << result << "}";
//}
#endif
return true;
}
bool load(const arguments & args_, std::string & result) {
HMODULE dllHandle;
RVExtension function;
LOG(INFO) << "Load requested [" << args_.as_string(0) << "]";
if (_modules.find(args_.as_string(0)) != _modules.end()) {
LOG(ERROR) << "Module already loaded [" << args_.as_string(0) << "]";
return true;
}
#ifdef _WINDOWS
// Make a copy of the file to temp, and load it from there, referencing the current path name
char tmpPath[MAX_PATH +1], buffer[MAX_PATH + 1];
if(!GetTempPathA(MAX_PATH, tmpPath)) {
LOG(ERROR) << "GetTempPath() failed, e=" << GetLastError();
return false;
}
if(!GetTempFileNameA(tmpPath, "ace_dynload", TRUE, buffer)) {
LOG(ERROR) << "GetTempFileName() failed, e=" << GetLastError();
return false;
}
std::string temp_filename = buffer;
if (!CopyFileA(args_.as_string(0).c_str(), temp_filename.c_str(), FALSE)) {
DeleteFile(temp_filename.c_str());
if (!CopyFileA(args_.as_string(0).c_str(), temp_filename.c_str(), FALSE)) {
LOG(ERROR) << "CopyFile() , e=" << GetLastError();
return false;
}
}
#else
std::string temp_filename = args_.as_string(0);
#endif
dllHandle = LoadLibrary(temp_filename.c_str());
if (!dllHandle) {
LOG(ERROR) << "LoadLibrary() failed, e=" << GetLastError() << " [" << args_.as_string(0) << "]";
return false;
}
function = (RVExtension)GetProcAddress(dllHandle, "_RVExtension@12");
if (!function) {
LOG(ERROR) << "GetProcAddress() failed, e=" << GetLastError() << " [" << args_.as_string(0) << "]";
FreeLibrary(dllHandle);
return false;
}
LOG(INFO) << "Load completed [" << args_.as_string(0) << "]";
_modules[args_.as_string(0)] = module(args_.as_string(0), dllHandle, function, temp_filename);
return false;
}
bool unload(const arguments & args_, std::string & result) {
LOG(INFO) << "Unload requested [" << args_.as_string(0) << "]";
if (_modules.find(args_.as_string(0)) == _modules.end()) {
LOG(INFO) << "Unload failed, module not loaded [" << args_.as_string(0) << "]";
return true;
}
if (!FreeLibrary(_modules[args_.as_string(0)].handle)) {
LOG(INFO) << "FreeLibrary() failed during unload, e=" << GetLastError();
return false;
}
//if (!DeleteFileA(_modules[args_.as_string(0)].temp_filename.c_str())) {
// LOG(INFO) << "DeleteFile() failed during unload, e=" << GetLastError();
// return false;
//}
_modules.erase(args_.as_string(0));
LOG(INFO) << "Unload complete [" << args_.as_string(0) << "]";
return true;
}
bool controller::export_ptr_list(const arguments &args_, std::string &) const {
std::ofstream pointers("sqf_pointers_declaration.hpp");
std::ofstream pointers_def("sqf_pointers_definitions.hpp");
std::ofstream assignments("sqf_assignments.hpp");
pointers << "//Exported Pointer Definitions For: " << args_.as_string(0) << "\n\n";
assignments << "//Exported Pointer Assignments For: " << args_.as_string(0) << "\n\n";
pointers << "\n// Unary Functions\n";
pointers_def << "\n// Unary Functions\n";
assignments << "\n// Unary Functions\n";
auto unary_list = loader::get().unary();
std::list<std::string> sorted_unary_list;
for (auto unary : unary_list) {
sorted_unary_list.push_back(unary.first);
}
sorted_unary_list.sort();
for (auto unary_entry : sorted_unary_list) {
std::string op_name = unary_entry;
std::regex name_test = std::regex("[a-z]+?.*");
if (std::regex_match(op_name, name_test)) {
for (auto op : unary_list[unary_entry]) {
std::string arg_types = op.op->arg_type.type_str();
std::transform(arg_types.begin(), arg_types.end(), arg_types.begin(), ::tolower);
std::string return_type = op.op->return_type.type_str();
std::transform(return_type.begin(), return_type.end(), return_type.begin(), ::tolower);
std::string first_arg_type = *op.op->arg_type.type().begin();
std::string pointer_name = "unary__" + op_name + "__" + arg_types + "__ret__" + return_type;
pointers_def << "unary_function __sqf::" << pointer_name << ";\n";
pointers << "static unary_function " << pointer_name << ";\n";
//__sqf::unary_random_scalar_raw = (unary_function)functions.get_unary_function_typed("random", "SCALAR");
assignments << "__sqf::" << pointer_name << " = " << "(unary_function)host::functions.get_unary_function_typed(\"" << op_name << "\"_sv, \"" << first_arg_type << "\"_sv);\n";
}
}
}
pointers << "\n// Binary Functions\n";
pointers_def << "\n// Binary Functions\n";
assignments << "\n// Binary Functions\n";
auto binary_list = loader::get().binary();
std::list<std::string> sorted_binary_list;
for (auto binary : binary_list) {
sorted_binary_list.push_back(binary.first);
};
sorted_binary_list.sort();
for (auto binary_entry : sorted_binary_list) {
std::string op_name = binary_entry;
std::regex name_test = std::regex("[a-z]+?.*");
if (std::regex_match(op_name, name_test)) {
for (auto op : binary_list[binary_entry]) {
std::string arg1_types = op.op->arg1_type.type_str();
std::transform(arg1_types.begin(), arg1_types.end(), arg1_types.begin(), ::tolower);
std::string arg2_types = op.op->arg2_type.type_str();
std::transform(arg2_types.begin(), arg2_types.end(), arg2_types.begin(), ::tolower);
std::string return_type = op.op->return_type.type_str();
std::transform(return_type.begin(), return_type.end(), return_type.begin(), ::tolower);
std::string first_arg1_type = *op.op->arg1_type.type().begin();
std::string first_arg2_type = *op.op->arg2_type.type().begin();
std::string pointer_name = "binary__" + op_name + "__" + arg1_types + "__" + arg2_types + "__ret__" + return_type;
pointers_def << "binary_function __sqf::" << pointer_name << ";\n";
pointers << "static binary_function " << pointer_name << ";\n";
assignments << "__sqf::" << pointer_name << " = " << "(binary_function)host::functions.get_binary_function_typed(\"" << op_name <<
"\"_sv, \"" << first_arg1_type << "\"_sv, \"" << first_arg2_type << "\"_sv);\n";
}
}
}
pointers << "\n// Nular Functions\n";
pointers_def << "\n// Nular Functions\n";
assignments << "\n// Nular Functions\n";
auto nular_list = loader::get().nular();
std::list<std::string> sorted_nular_list;
for (auto nular : nular_list) {
sorted_nular_list.push_back(nular.first);
};
sorted_nular_list.sort();
for (auto nular_entry : sorted_nular_list) {
std::string op_name = nular_entry;
std::regex name_test = std::regex("[a-z]+?.*");
if (std::regex_match(op_name, name_test)) {
for (auto op : nular_list[nular_entry]) {
std::string return_type = op.op->return_type.type_str();
std::transform(return_type.begin(), return_type.end(), return_type.begin(), ::tolower);
std::string pointer_name = "nular__" + op_name + "__ret__" + return_type;
pointers_def << "nular_function __sqf::" << pointer_name << ";\n";
pointers << "static nular_function " << pointer_name << ";\n";
//__sqf::unary_random_scalar_raw = (unary_function)functions.get_unary_function_typed("random", "SCALAR");
assignments << "__sqf::" << pointer_name << " = " << "(nular_function)host::functions.get_nular_function(\"" << op_name << "\"_sv);\n";
}
}
}
return true;
}
