init commit
This commit is contained in:
parent
3bfcfcbbe8
commit
febeaaa1eb
GPG Key ID:
00610B08C1BF7BE9
|
|
@ -0,0 +1,7 @@
|
|||
/.idea
|
||||
/.theos
|
||||
/.theos/obj/arm64/GakumasLocalify/GakumasLocalify/config/Config.cpp.bdae6e5c.o
|
||||
/.vs
|
||||
/.vs/gakumas_localify_ios_no_il2cpp/CopilotIndices/17.13.439.2385/CodeChunks.db
|
||||
/packages
|
||||
/il2cpp_find_readme.txt.cpp
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#include "../../src/platformDefine.hpp"
|
||||
|
||||
#if defined(GKMS_ANDROID) || defined(GKMS_IOS)
|
||||
#define KEY_W 51
|
||||
#define KEY_S 47
|
||||
#define KEY_A 29
|
||||
#define KEY_D 32
|
||||
#define KEY_R 46
|
||||
#define KEY_Q 45
|
||||
#define KEY_E 33
|
||||
#define KEY_F 34
|
||||
#define KEY_I 37
|
||||
#define KEY_K 39
|
||||
#define KEY_J 38
|
||||
#define KEY_L 40
|
||||
#define KEY_V 50
|
||||
#define KEY_UP 19
|
||||
#define KEY_DOWN 20
|
||||
#define KEY_LEFT 21
|
||||
#define KEY_RIGHT 22
|
||||
#define KEY_CTRL 113
|
||||
#define KEY_SHIFT 59
|
||||
#define KEY_ALT 57
|
||||
#define KEY_SPACE 62
|
||||
#define KEY_ADD 70
|
||||
#define KEY_SUB 69
|
||||
|
||||
#define WM_KEYDOWN 0
|
||||
#define WM_KEYUP 1
|
||||
#else
|
||||
#define KEY_W 'W'
|
||||
#define KEY_S 'S'
|
||||
#define KEY_A 'A'
|
||||
#define KEY_D 'D'
|
||||
#define KEY_R 'R'
|
||||
#define KEY_Q 'Q'
|
||||
#define KEY_E 'E'
|
||||
#define KEY_F 'F'
|
||||
#define KEY_I 'I'
|
||||
#define KEY_K 'K'
|
||||
#define KEY_J 'J'
|
||||
#define KEY_L 'L'
|
||||
#define KEY_V 'V'
|
||||
#define KEY_UP 38
|
||||
#define KEY_DOWN 40
|
||||
#define KEY_LEFT 37
|
||||
#define KEY_RIGHT 39
|
||||
#define KEY_CTRL 17
|
||||
#define KEY_SHIFT 16
|
||||
#define KEY_ALT 18
|
||||
#define KEY_SPACE 32
|
||||
|
||||
#define KEY_ADD 187
|
||||
#define KEY_SUB 189
|
||||
#endif
|
||||
|
||||
#define BTN_A 96
|
||||
#define BTN_B 97
|
||||
#define BTN_X 99
|
||||
#define BTN_Y 100
|
||||
#define BTN_LB 102
|
||||
#define BTN_RB 103
|
||||
#define BTN_THUMBL 106
|
||||
#define BTN_THUMBR 107
|
||||
#define BTN_SELECT 109
|
||||
#define BTN_START 108
|
||||
#define BTN_SHARE 130
|
||||
#define BTN_XBOX 110
|
||||
|
|
@ -0,0 +1,639 @@
|
|||
#include "Hook.h"
|
||||
#include "Plugin.h"
|
||||
#include "Log.h"
|
||||
#include "Il2cppUtils.hpp"
|
||||
#include "Local.h"
|
||||
#include "MasterLocal.h"
|
||||
#include <unordered_set>
|
||||
#include <algorithm>
|
||||
#include "config/Config.hpp"
|
||||
// #include <jni.h>
|
||||
#include <thread>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include "../../src/platformDefine.hpp"
|
||||
#include "../../src/UpdateChecker.h"
|
||||
#include "../il2cpp_dump/il2cppTypes.hpp"
|
||||
|
||||
#ifdef GKMS_WINDOWS
|
||||
#include "../windowsPlatform.hpp"
|
||||
#include "cpprest/details/http_helpers.h"
|
||||
#include "../resourceUpdate/resourceUpdate.hpp"
|
||||
#endif
|
||||
|
||||
|
||||
std::unordered_set<void*> hookedStubs{};
|
||||
extern std::filesystem::path gakumasLocalPath;
|
||||
|
||||
#define DEFINE_HOOK(returnType, name, params) \
|
||||
using name##_Type = returnType(*) params; \
|
||||
name##_Type name##_Addr = nullptr; \
|
||||
name##_Type name##_Orig = nullptr; \
|
||||
returnType name##_Hook params
|
||||
|
||||
/*
|
||||
void UnHookAll() {
|
||||
for (const auto i: hookedStubs) {
|
||||
int result = shadowhook_unhook(i);
|
||||
if(result != 0)
|
||||
{
|
||||
int error_num = shadowhook_get_errno();
|
||||
const char *error_msg = shadowhook_to_errmsg(error_num);
|
||||
GakumasLocal::Log::ErrorFmt("unhook failed: %d - %s", error_num, error_msg);
|
||||
}
|
||||
}
|
||||
}*/
|
||||
|
||||
using Il2cppString = Il2cppTypes::String;
|
||||
|
||||
namespace GakumasLocal::HookMain {
|
||||
|
||||
DEFINE_HOOK(void, Internal_LogException, (void* ex, void* obj)) {
|
||||
Internal_LogException_Orig(ex, obj);
|
||||
static auto Exception_ToString = Il2cppUtils::GetMethod("mscorlib.dll", "System", "Exception", "ToString", 0);
|
||||
Log::LogUnityLog(ANDROID_LOG_ERROR, "UnityLog - Internal_LogException:\n%s", Exception_ToString->Invoke<Il2cppString*>(ex)->ToString().c_str());
|
||||
}
|
||||
|
||||
DEFINE_HOOK(void, Internal_Log, (int logType, int logOption, Il2cppString* content, void* context)) {
|
||||
Internal_Log_Orig(logType, logOption, content, context);
|
||||
// 2022.3.21f1
|
||||
Log::LogUnityLog(ANDROID_LOG_VERBOSE, "Internal_Log:\n%s", content->ToString().c_str());
|
||||
}
|
||||
|
||||
bool IsNativeObjectAlive(void* obj) {
|
||||
static Il2cppJson::Method* IsNativeObjectAliveMtd = nullptr;
|
||||
if (!IsNativeObjectAliveMtd) IsNativeObjectAliveMtd = Il2cppUtils::GetMethod("UnityEngine.CoreModule.dll", "UnityEngine",
|
||||
"Object", "IsNativeObjectAlive", 1);
|
||||
return IsNativeObjectAliveMtd->Invoke<bool>(obj);
|
||||
}
|
||||
|
||||
/*
|
||||
UnityResolve::UnityType::Camera* mainCameraCache = nullptr;
|
||||
UnityResolve::UnityType::Transform* cameraTransformCache = nullptr;
|
||||
void CheckAndUpdateMainCamera() {
|
||||
if (!Config::enableFreeCamera) return;
|
||||
if (IsNativeObjectAlive(mainCameraCache) && IsNativeObjectAlive(cameraTransformCache)) return;
|
||||
|
||||
mainCameraCache = UnityResolve::UnityType::Camera::GetMain();
|
||||
cameraTransformCache = mainCameraCache->GetTransform();
|
||||
}*/
|
||||
|
||||
Il2cppUtils::Resolution_t GetResolution() {
|
||||
static auto GetResolution = Il2cppUtils::GetMethod("UnityEngine.CoreModule.dll", "UnityEngine",
|
||||
"Screen", "get_currentResolution", 0);
|
||||
return GetResolution->Invoke<Il2cppUtils::Resolution_t>();
|
||||
}
|
||||
|
||||
Il2cppString* ToJsonStr(void* object) {
|
||||
static Il2cppString* (*toJsonStr)(void*) = nullptr;
|
||||
if (!toJsonStr) {
|
||||
toJsonStr = reinterpret_cast<Il2cppString * (*)(void*)>(Il2cppUtils::GetMethodPointer("Newtonsoft.Json.dll", "Newtonsoft.Json",
|
||||
"JsonConvert", "SerializeObject", 1
|
||||
// { "*" }
|
||||
));
|
||||
}
|
||||
if (!toJsonStr) {
|
||||
return nullptr;
|
||||
}
|
||||
return toJsonStr(object);
|
||||
}
|
||||
|
||||
#ifdef GKMS_WINDOWS
|
||||
DEFINE_HOOK(void*, InternalSetOrientationAsync, (void* retstr, void* self, int type, void* c, void* tc, void* mtd)) {
|
||||
switch (Config::gameOrientation) {
|
||||
case 1: type = 0x2; break; // FixedPortrait
|
||||
case 2: type = 0x3; break; // FixedLandscape
|
||||
default: break;
|
||||
}
|
||||
return InternalSetOrientationAsync_Orig(retstr, self, type, c, tc, mtd);
|
||||
}
|
||||
#else
|
||||
DEFINE_HOOK(void*, InternalSetOrientationAsync, (void* self, int type, void* c, void* tc, void* mtd)) {
|
||||
switch (Config::gameOrientation) {
|
||||
case 1: type = 0x2; break; // FixedPortrait
|
||||
case 2: type = 0x3; break; // FixedLandscape
|
||||
default: break;
|
||||
}
|
||||
return InternalSetOrientationAsync_Orig(self, type, c, tc, mtd);
|
||||
}
|
||||
#endif
|
||||
/*
|
||||
DEFINE_HOOK(void, EndCameraRendering, (void* ctx, void* camera, void* method)) {
|
||||
EndCameraRendering_Orig(ctx, camera, method);
|
||||
|
||||
if (Config::enableFreeCamera && mainCameraCache) {
|
||||
Unity_set_fieldOfView_Orig(mainCameraCache, GKCamera::baseCamera.fov);
|
||||
if (GKCamera::GetCameraMode() == GKCamera::CameraMode::FIRST_PERSON) {
|
||||
mainCameraCache->SetNearClipPlane(0.001f);
|
||||
}
|
||||
}
|
||||
}*/
|
||||
|
||||
DEFINE_HOOK(void, Unity_set_targetFrameRate, (int value)) {
|
||||
const auto configFps = Config::targetFrameRate;
|
||||
return Unity_set_targetFrameRate_Orig(configFps == 0 ? value: configFps);
|
||||
}
|
||||
|
||||
DEFINE_HOOK(void, I18nHelper_SetUpI18n, (void* self, Il2cppString* lang, Il2cppString* localizationText, int keyComparison)) {
|
||||
// Log::InfoFmt("SetUpI18n lang: %s, key: %d text: %s", lang->ToString().c_str(), keyComparison, localizationText->ToString().c_str());
|
||||
// TODO 此处为 dump 原文 csv
|
||||
I18nHelper_SetUpI18n_Orig(self, lang, localizationText, keyComparison);
|
||||
}
|
||||
|
||||
DEFINE_HOOK(void, I18nHelper_SetValue, (void* self, Il2cppString* key, Il2cppString* value)) {
|
||||
// Log::InfoFmt("I18nHelper_SetValue: %s - %s", key->ToString().c_str(), value->ToString().c_str());
|
||||
std::string local;
|
||||
if (Local::GetI18n(key->ToString(), &local)) {
|
||||
I18nHelper_SetValue_Orig(self, key, Il2cppString::New(local));
|
||||
return;
|
||||
}
|
||||
Local::DumpI18nItem(key->ToString(), value->ToString());
|
||||
if (Config::textTest) {
|
||||
I18nHelper_SetValue_Orig(self, key, Il2cppString::New("[I18]" + value->ToString()));
|
||||
}
|
||||
else {
|
||||
I18nHelper_SetValue_Orig(self, key, value);
|
||||
}
|
||||
}
|
||||
|
||||
void* fontCache = nullptr;
|
||||
void* GetReplaceFont(void* origFont) {
|
||||
static auto fontName = Local::GetBasePath() / "local-files" / "gkamsZHFontMIX.otf";
|
||||
if (!std::filesystem::exists(fontName)) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
static auto CreateFontFromPath = reinterpret_cast<void (*)(void* self, Il2cppString* path)>(
|
||||
Il2cppUtils::GetMethodPointer("UnityEngine.TextRenderingModule.dll", "UnityEngine", "Font",
|
||||
"Internal_CreateFontFromPath", 2)
|
||||
);
|
||||
static auto Font_klass = Il2cppUtils::GetClass("UnityEngine.TextRenderingModule.dll",
|
||||
"UnityEngine", "Font");
|
||||
static auto Font_ctor = Il2cppUtils::GetMethod("UnityEngine.TextRenderingModule.dll",
|
||||
"UnityEngine", "Font", ".ctor", 0);
|
||||
if (fontCache) {
|
||||
if (IsNativeObjectAlive(fontCache)) {
|
||||
return fontCache;
|
||||
}
|
||||
}
|
||||
|
||||
auto klassAddr = Il2cppUtils::get_class_from_instance(origFont);
|
||||
// static auto klassAddr = Il2cppUtils::GetIl2cppClassFromName("UnityEngine.TextRenderingModule.dll", "UnityEngine", "Font");
|
||||
const auto newFont = Font_klass->New(klassAddr);
|
||||
Font_ctor->Invoke<void>(newFont);
|
||||
|
||||
CreateFontFromPath(newFont, Il2cppString::New(fontName.string()));
|
||||
fontCache = newFont;
|
||||
return newFont;
|
||||
}
|
||||
|
||||
std::unordered_set<void*> updatedFontPtrs{};
|
||||
void UpdateFont(void* TMP_Textself) {
|
||||
if (!Config::replaceFont) return;
|
||||
static auto get_font = Il2cppUtils::GetMethod("Unity.TextMeshPro.dll",
|
||||
"TMPro", "TMP_Text", "get_font");
|
||||
static auto set_font = Il2cppUtils::GetMethod("Unity.TextMeshPro.dll",
|
||||
"TMPro", "TMP_Text", "set_font");
|
||||
static auto get_name = Il2cppUtils::GetMethod("UnityEngine.CoreModule.dll",
|
||||
"UnityEngine", "Object", "get_name");
|
||||
// static auto set_fontMaterial = Il2cppUtils::GetMethod("Unity.TextMeshPro.dll",
|
||||
// "TMPro", "TMP_Text", "set_fontMaterial");
|
||||
// static auto ForceMeshUpdate = Il2cppUtils::GetMethod("Unity.TextMeshPro.dll",
|
||||
// "TMPro", "TMP_Text", "ForceMeshUpdate");
|
||||
//
|
||||
// static auto get_material = Il2cppUtils::GetMethod("Unity.TextMeshPro.dll",
|
||||
// "TMPro", "TMP_Asset", "get_material");
|
||||
|
||||
static auto set_sourceFontFile = Il2cppUtils::GetMethod("Unity.TextMeshPro.dll", "TMPro",
|
||||
"TMP_FontAsset", "set_sourceFontFile");
|
||||
static auto UpdateFontAssetData = Il2cppUtils::GetMethod("Unity.TextMeshPro.dll", "TMPro",
|
||||
"TMP_FontAsset", "UpdateFontAssetData");
|
||||
|
||||
auto fontAsset = get_font->Invoke<void*>(TMP_Textself);
|
||||
if (!fontAsset) {
|
||||
return;
|
||||
}
|
||||
|
||||
// 检查字体名称，跳过 CampusAlphanumeric 系列字体
|
||||
auto fontAssetName = get_name->Invoke<Il2cppString*>(fontAsset);
|
||||
if (fontAssetName) {
|
||||
std::string fontName = fontAssetName->ToString();
|
||||
std::transform(fontName.begin(), fontName.end(), fontName.begin(),
|
||||
[](unsigned char c) { return std::tolower(c); });
|
||||
if (fontName.find("campusalphanumeric") != std::string::npos) {
|
||||
return; // 保持原版数字字体
|
||||
}
|
||||
}
|
||||
|
||||
auto newFont = GetReplaceFont(fontAsset);
|
||||
if (!newFont) return;
|
||||
|
||||
set_sourceFontFile->Invoke<void>(fontAsset, newFont);
|
||||
if (!updatedFontPtrs.contains(fontAsset)) {
|
||||
updatedFontPtrs.emplace(fontAsset);
|
||||
UpdateFontAssetData->Invoke<void>(fontAsset);
|
||||
}
|
||||
if (updatedFontPtrs.size() > 200) updatedFontPtrs.clear();
|
||||
|
||||
set_font->Invoke<void>(TMP_Textself, fontAsset);
|
||||
|
||||
//auto fontMaterial = get_material->Invoke<void*>(fontAsset);
|
||||
//set_fontMaterial->Invoke<void>(TMP_Textself, fontMaterial);
|
||||
//ForceMeshUpdate->Invoke<void>(TMP_Textself, false, false);
|
||||
}
|
||||
|
||||
DEFINE_HOOK(void, TMP_Text_PopulateTextBackingArray, (void* self, Il2cppString* text, int start, int length)) {
|
||||
if (!text) {
|
||||
return TMP_Text_PopulateTextBackingArray_Orig(self, text, start, length);
|
||||
}
|
||||
|
||||
static auto Substring = Il2cppUtils::GetMethod("mscorlib.dll", "System", "String", "Substring",
|
||||
// {"System.Int32", "System.Int32"}
|
||||
{"Int32", "Int32"}
|
||||
);
|
||||
|
||||
const std::string origText = Substring->Invoke<Il2cppString*>(text, start, length)->ToString();
|
||||
std::string transText;
|
||||
if (Local::GetGenericText(origText, &transText)) {
|
||||
// Log::DebugFmt("GetGenericText[TP]: %s -> %s (%ls)", origText.c_str(), transText.c_str(), Substring->Invoke<Il2cppString*>(text, start, length)->chars);
|
||||
const auto newText = Il2cppString::New(transText);
|
||||
UpdateFont(self);
|
||||
return TMP_Text_PopulateTextBackingArray_Orig(self, newText, 0, newText->length);
|
||||
}
|
||||
|
||||
if (Config::textTest) {
|
||||
TMP_Text_PopulateTextBackingArray_Orig(self, Il2cppString::New("[TP]" + text->ToString()), start, length + 4);
|
||||
}
|
||||
else {
|
||||
TMP_Text_PopulateTextBackingArray_Orig(self, text, start, length);
|
||||
}
|
||||
UpdateFont(self);
|
||||
}
|
||||
|
||||
DEFINE_HOOK(void, TMP_Text_set_text, (void* self, Il2cppString* value, void* mtd)) {
|
||||
if (!value) {
|
||||
return TMP_Text_set_text_Orig(self, value, mtd);
|
||||
}
|
||||
const std::string origText = value->ToString();
|
||||
std::string transText;
|
||||
if (Local::GetGenericText(origText, &transText)) {
|
||||
const auto newText = Il2cppString::New(transText);
|
||||
UpdateFont(self);
|
||||
return TMP_Text_set_text_Orig(self, newText, mtd);
|
||||
}
|
||||
if (Config::textTest) {
|
||||
TMP_Text_set_text_Orig(self, Il2cppString::New("[TT]" + origText), mtd);
|
||||
}
|
||||
else {
|
||||
TMP_Text_set_text_Orig(self, value, mtd);
|
||||
}
|
||||
UpdateFont(self);
|
||||
}
|
||||
|
||||
DEFINE_HOOK(void, TMP_Text_SetText_1, (void* self, Il2cppString* sourceText, void* mtd)) {
|
||||
if (!sourceText) {
|
||||
return TMP_Text_SetText_1_Orig(self, sourceText, mtd);
|
||||
}
|
||||
const std::string origText = sourceText->ToString();
|
||||
std::string transText;
|
||||
if (Local::GetGenericText(origText, &transText)) {
|
||||
const auto newText = Il2cppString::New(transText);
|
||||
UpdateFont(self);
|
||||
return TMP_Text_SetText_1_Orig(self, newText, mtd);
|
||||
}
|
||||
if (Config::textTest) {
|
||||
TMP_Text_SetText_1_Orig(self, Il2cppString::New("[T1]" + origText), mtd);
|
||||
}
|
||||
else {
|
||||
TMP_Text_SetText_1_Orig(self, sourceText, mtd);
|
||||
}
|
||||
UpdateFont(self);
|
||||
}
|
||||
|
||||
DEFINE_HOOK(void, TMP_Text_SetText_2, (void* self, Il2cppString* sourceText, bool syncTextInputBox, void* mtd)) {
|
||||
if (!sourceText) {
|
||||
return TMP_Text_SetText_2_Orig(self, sourceText, syncTextInputBox, mtd);
|
||||
}
|
||||
const std::string origText = sourceText->ToString();
|
||||
std::string transText;
|
||||
if (Local::GetGenericText(origText, &transText)) {
|
||||
// Log::DebugFmt("GetGenericText[TS]: %s -> %s (%ls)", origText.c_str(), transText.c_str(), sourceText->chars);
|
||||
const auto newText = Il2cppString::New(transText);
|
||||
UpdateFont(self);
|
||||
return TMP_Text_SetText_2_Orig(self, newText, syncTextInputBox, mtd);
|
||||
}
|
||||
if (Config::textTest) {
|
||||
TMP_Text_SetText_2_Orig(self, Il2cppString::New("[TS]" + sourceText->ToString()), syncTextInputBox, mtd);
|
||||
}
|
||||
else {
|
||||
TMP_Text_SetText_2_Orig(self, sourceText, syncTextInputBox, mtd);
|
||||
}
|
||||
UpdateFont(self);
|
||||
}
|
||||
|
||||
DEFINE_HOOK(void, TextMeshProUGUI_Awake, (void* self, void* method)) {
|
||||
// Log::InfoFmt("TextMeshProUGUI_Awake at %p, self at %p", TextMeshProUGUI_Awake_Orig, self);
|
||||
|
||||
const auto TMP_Text_klass = Il2cppUtils::GetClass("Unity.TextMeshPro.dll",
|
||||
"TMPro", "TMP_Text");
|
||||
const auto get_Text_method = TMP_Text_klass->GetMethod("get_text");
|
||||
const auto set_Text_method = TMP_Text_klass->GetMethod("set_text");
|
||||
const auto currText = get_Text_method->Invoke<Il2cppString*>(self);
|
||||
if (currText) {
|
||||
//Log::InfoFmt("TextMeshProUGUI_Awake: %s", currText->ToString().c_str());
|
||||
std::string transText;
|
||||
if (Local::GetGenericText(currText->ToString(), &transText)) {
|
||||
// Log::DebugFmt("GetGenericText[TA]: %s -> %s (%ls)", currText->ToString().c_str(), transText.c_str(), currText->chars);
|
||||
if (Config::textTest) {
|
||||
set_Text_method->Invoke<void>(self, Il2cppString::New("[TA]" + transText));
|
||||
}
|
||||
else {
|
||||
set_Text_method->Invoke<void>(self, Il2cppString::New(transText));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// set_font->Invoke<void>(self, font);
|
||||
UpdateFont(self);
|
||||
TextMeshProUGUI_Awake_Orig(self, method);
|
||||
}
|
||||
|
||||
// Legacy UnityEngine.UI.Text hook（礼物/邮件等非TMP界面）
|
||||
DEFINE_HOOK(void, UIText_set_text, (void* self, Il2cppString* value)) {
|
||||
if (!value) {
|
||||
return UIText_set_text_Orig(self, value);
|
||||
}
|
||||
const std::string origText = value->ToString();
|
||||
std::string transText;
|
||||
if (Local::GetGenericText(origText, &transText)) {
|
||||
const auto newText = Il2cppString::New(transText);
|
||||
return UIText_set_text_Orig(self, newText);
|
||||
}
|
||||
if (Config::textTest) {
|
||||
UIText_set_text_Orig(self, Il2cppString::New("[UI]" + origText));
|
||||
}
|
||||
else {
|
||||
UIText_set_text_Orig(self, value);
|
||||
}
|
||||
}
|
||||
|
||||
// TMP_Text.SetCharArray(char[], int, int) — 礼物/邮件描述文字通过此路径设置
|
||||
DEFINE_HOOK(void, TMP_Text_SetCharArray, (void* self, Il2cppTypes::Array<u_int16_t>* charArray, int start, int count, void* mtd)) {
|
||||
if (charArray && start >= 0 && count > 0) {
|
||||
// IL2CPP char[] elements are uint16_t (UTF-16)
|
||||
// 边界检查：确保 start+count 不超出数组长度
|
||||
if (static_cast<uintptr_t>(start + count) <= charArray->max_length) {
|
||||
auto rawData = charArray->GetData();
|
||||
if (rawData) {
|
||||
// rawData 是 uintptr_t（字节地址），每个 char16_t 占 2 字节
|
||||
// 必须用 start * sizeof(char16_t) 而非直接 + start（否则偏移量减半）
|
||||
const std::u16string u16(
|
||||
reinterpret_cast<const char16_t*>(rawData + static_cast<uintptr_t>(start) * sizeof(char16_t)),
|
||||
static_cast<size_t>(count));
|
||||
const std::string origText = Misc::ToUTF8(u16);
|
||||
std::string transText;
|
||||
if (Local::GetGenericText(origText, &transText)) {
|
||||
UpdateFont(self);
|
||||
TMP_Text_set_text_Orig(self, Il2cppString::New(transText), nullptr);
|
||||
return;
|
||||
}
|
||||
if (Config::textTest) {
|
||||
UpdateFont(self);
|
||||
TMP_Text_set_text_Orig(self, Il2cppString::New("[CA]" + origText), nullptr);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
TMP_Text_SetCharArray_Orig(self, charArray, start, count, mtd);
|
||||
}
|
||||
|
||||
DEFINE_HOOK(void, TextField_set_value, (void* self, Il2cppString* value)) {
|
||||
if (value) {
|
||||
std::string transText;
|
||||
if (Local::GetGenericText(value->ToString(), &transText)) {
|
||||
return TextField_set_value_Orig(self, Il2cppString::New(transText));
|
||||
}
|
||||
}
|
||||
TextField_set_value_Orig(self, value);
|
||||
}
|
||||
|
||||
|
||||
// 用于本地化 MasterDB
|
||||
DEFINE_HOOK(void, MessageExtensions_MergeFrom, (void* message, void* span, void* mtd)) {
|
||||
MessageExtensions_MergeFrom_Orig(message, span, mtd);
|
||||
if (message) {
|
||||
auto ret_klass = Il2cppUtils::get_class_from_instance(message);
|
||||
if (ret_klass) {
|
||||
// Log::DebugFmt("LocalizeMasterItem: %s", ret_klass->name);
|
||||
MasterLocal::LocalizeMasterItem(message, ret_klass->name);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
DEFINE_HOOK(Il2cppString*, OctoCaching_GetResourceFileName, (void* data, void* method)) {
|
||||
auto ret = OctoCaching_GetResourceFileName_Orig(data, method);
|
||||
//Log::DebugFmt("OctoCaching_GetResourceFileName: %s", ret->ToString().c_str());
|
||||
return ret;
|
||||
}
|
||||
|
||||
DEFINE_HOOK(void, OctoResourceLoader_LoadFromCacheOrDownload,
|
||||
(void* self, Il2cppString* resourceName, void* onComplete, void* onProgress, void* method)) {
|
||||
|
||||
Log::DebugFmt("OctoResourceLoader_LoadFromCacheOrDownload: %s\n", resourceName->ToString().c_str());
|
||||
|
||||
std::string replaceStr;
|
||||
if (Local::GetResourceText(resourceName->ToString(), &replaceStr)) {
|
||||
const auto onComplete_klass = Il2cppUtils::get_class_from_instance(onComplete);
|
||||
const auto onComplete_invoke_mtd = Il2cppJson::InvokeIl2cpp<Il2cppUtils::MethodInfo*>(
|
||||
"il2cpp_class_get_method_from_name", onComplete_klass, "Invoke", 2);
|
||||
if (onComplete_invoke_mtd) {
|
||||
const auto onComplete_invoke = reinterpret_cast<void (*)(void*, Il2cppString*, void*)>(
|
||||
onComplete_invoke_mtd->methodPointer
|
||||
);
|
||||
onComplete_invoke(onComplete, Il2cppString::New(replaceStr), nullptr);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
return OctoResourceLoader_LoadFromCacheOrDownload_Orig(self, resourceName, onComplete, onProgress, method);
|
||||
}
|
||||
|
||||
|
||||
// UnHooked
|
||||
DEFINE_HOOK(Il2cppString*, UI_I18n_GetOrDefault, (void* self,
|
||||
Il2cppString* key, Il2cppString* defaultKey, void* method)) {
|
||||
|
||||
auto ret = UI_I18n_GetOrDefault_Orig(self, key, defaultKey, method);
|
||||
|
||||
// Log::DebugFmt("UI_I18n_GetOrDefault: key: %s, default: %s, result: %s", key->ToString().c_str(), defaultKey->ToString().c_str(), ret->ToString().c_str());
|
||||
|
||||
return ret;
|
||||
// return Il2cppString::New("[I18]" + ret->ToString());
|
||||
}
|
||||
|
||||
|
||||
void StartInjectFunctions() {
|
||||
const auto hookInstaller = Plugin::GetInstance().GetHookInstaller();
|
||||
|
||||
// UnityResolve::Init(xdl_open(hookInstaller->m_il2cppLibraryPath.c_str(), RTLD_NOW),
|
||||
// UnityResolve::Mode::Il2Cpp, Config::lazyInit);
|
||||
|
||||
ADD_HOOK(I18nHelper_SetUpI18n, Il2cppUtils::GetMethodPointer("quaunity-ui.Runtime.dll", "Qua.UI",
|
||||
"I18nHelper", "SetUpI18n", 3));
|
||||
ADD_HOOK(I18nHelper_SetValue, Il2cppUtils::GetMethodPointer("quaunity-ui.Runtime.dll", "Qua.UI",
|
||||
"I18n", "SetValue", 2));
|
||||
|
||||
//ADD_HOOK(UI_I18n_GetOrDefault, Il2cppUtils::GetMethodPointer("quaunity-ui.Runtime.dll", "Qua.UI",
|
||||
// "I18n", "GetOrDefault"));
|
||||
|
||||
ADD_HOOK(TextMeshProUGUI_Awake, Il2cppUtils::GetMethodPointer("Unity.TextMeshPro.dll", "TMPro",
|
||||
"TextMeshProUGUI", "Awake", 0));
|
||||
|
||||
ADD_HOOK(TMP_Text_set_text, Il2cppUtils::GetMethodPointer("Unity.TextMeshPro.dll", "TMPro",
|
||||
"TMP_Text", "set_text"));
|
||||
ADD_HOOK(TMP_Text_SetText_1, Il2cppUtils::GetMethodPointer("Unity.TextMeshPro.dll", "TMPro",
|
||||
"TMP_Text", "SetText",
|
||||
{"String"}));
|
||||
|
||||
// 处理
|
||||
ADD_HOOK(TMP_Text_PopulateTextBackingArray, Il2cppUtils::GetMethodPointer("Unity.TextMeshPro.dll", "TMPro",
|
||||
"TMP_Text", "PopulateTextBackingArray",
|
||||
// {"System.String", "System.Int32", "System.Int32"}
|
||||
{"String", "Int32", "Int32"}
|
||||
));
|
||||
ADD_HOOK(TMP_Text_SetText_2, Il2cppUtils::GetMethodPointer("Unity.TextMeshPro.dll", "TMPro",
|
||||
"TMP_Text", "SetText",
|
||||
{ "System.String", "System.Boolean" }
|
||||
));
|
||||
|
||||
ADD_HOOK(TextField_set_value, Il2cppUtils::GetMethodPointer("UnityEngine.UIElementsModule.dll", "UnityEngine.UIElements",
|
||||
"TextField", "set_value", 1));
|
||||
|
||||
// Legacy UnityEngine.UI.Text hook
|
||||
{
|
||||
auto uiTextPtr = Il2cppUtils::GetMethodPointer("UnityEngine.UI.dll", "UnityEngine.UI",
|
||||
"Text", "set_text");
|
||||
if (uiTextPtr) {
|
||||
ADD_HOOK(UIText_set_text, uiTextPtr);
|
||||
}
|
||||
else {
|
||||
Log::InfoFmt("UIText_set_text: method not found, legacy UI.Text hook skipped.");
|
||||
}
|
||||
}
|
||||
|
||||
ADD_HOOK(TMP_Text_SetCharArray, Il2cppUtils::GetMethodPointer("Unity.TextMeshPro.dll", "TMPro",
|
||||
"TMP_Text", "SetCharArray", {"Char[]", "Int32", "Int32"}));
|
||||
|
||||
// 处理
|
||||
ADD_HOOK(MessageExtensions_MergeFrom, Il2cppUtils::GetMethodPointer("Google.Protobuf.dll", "Google.Protobuf",
|
||||
"MessageExtensions", "MergeFrom",
|
||||
// {"Google.Protobuf.IMessage", "System.ReadOnlySpan<System.Byte>"}
|
||||
{"IMessage", "ReadOnlySpan`1[Byte]"}
|
||||
));
|
||||
|
||||
|
||||
ADD_HOOK(OctoCaching_GetResourceFileName, Il2cppUtils::GetMethodPointer("Octo.dll", "Octo.Caching",
|
||||
"OctoCaching", "GetResourceFileName", 1));
|
||||
|
||||
// 处理
|
||||
ADD_HOOK(OctoResourceLoader_LoadFromCacheOrDownload,
|
||||
Il2cppUtils::GetMethodPointer("Octo.dll", "Octo.Loader",
|
||||
"OctoResourceLoader", "LoadFromCacheOrDownload",
|
||||
// {"System.String", "System.Action<System.String,Octo.LoadError>", "Octo.OnDownloadProgress"}
|
||||
{"String", "Action`2[String,Octo.LoadError]", "OnDownloadProgress"}
|
||||
));
|
||||
|
||||
ADD_HOOK(Internal_LogException, Il2cppJson::InvokeIl2cpp<void*>("il2cpp_resolve_icall",
|
||||
"UnityEngine.DebugLogHandler::Internal_LogException(System.Exception,UnityEngine.Object)"));
|
||||
ADD_HOOK(Internal_Log, Il2cppJson::InvokeIl2cpp<void*>("il2cpp_resolve_icall",
|
||||
"UnityEngine.DebugLogHandler::Internal_Log(UnityEngine.LogType,UnityEngine.LogOption,System.String,UnityEngine.Object)"));
|
||||
|
||||
// 双端
|
||||
ADD_HOOK(InternalSetOrientationAsync,
|
||||
Il2cppUtils::GetMethodPointer("campus-submodule.Runtime.dll", "Campus.Common",
|
||||
"ScreenOrientationControllerBase", "InternalSetOrientationAsync", 3));
|
||||
|
||||
}
|
||||
// 77 2640 5000
|
||||
|
||||
bool hookStarted = false;
|
||||
void StartHook()
|
||||
{
|
||||
if (hookStarted) return;
|
||||
hookStarted = true;
|
||||
|
||||
Log::Info("Waiting for update check to complete...");
|
||||
while (!g_updateCheckDone.load()) {
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(100));
|
||||
}
|
||||
Log::Info("Update check done, waiting for config...");
|
||||
|
||||
while (!Config::isConfigInit) {
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(100));
|
||||
}
|
||||
if (!Config::enabled) {
|
||||
Log::Info("Plugin not enabled");
|
||||
return;
|
||||
}
|
||||
|
||||
Log::Info("Start init plugin...");
|
||||
|
||||
StartInjectFunctions();
|
||||
// GKCamera::initCameraSettings();
|
||||
|
||||
Local::LoadData();
|
||||
MasterLocal::LoadData();
|
||||
|
||||
Log::Info("Plugin init finished.");
|
||||
Log::ShowToastFmt("插件加载完成 / Plugin loaded: %s", PLUGIN_VERSION);
|
||||
}
|
||||
|
||||
|
||||
DEFINE_HOOK(int, il2cpp_init, (const char* domain_name)) {
|
||||
const auto ret = il2cpp_init_Orig(domain_name);
|
||||
// InjectFunctions();
|
||||
StartHook();
|
||||
return ret;
|
||||
}
|
||||
|
||||
DEFINE_HOOK(int64_t, criWare, ()) {
|
||||
const auto ret = criWare_Orig();
|
||||
// InjectFunctions();
|
||||
StartHook();
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
namespace GakumasLocal::Hook {
|
||||
void Install() {
|
||||
const auto hookInstaller = Plugin::GetInstance().GetHookInstaller();
|
||||
|
||||
Log::Info("Installing hook");
|
||||
|
||||
/*
|
||||
auto testAddress = Il2cppUtils::GetMethodPointer("quaunity-ui.Runtime.dll", "Qua.UI",
|
||||
"I18nHelper", "SetUpI18n");
|
||||
Log::InfoFmt("TestSetUpI18n Address: %p", testAddress);
|
||||
|
||||
auto testKlassAddr = Il2cppUtils::GetIl2cppClassFromName("UnityEngine.TextRenderingModule.dll",
|
||||
"UnityEngine", "Font");
|
||||
Log::InfoFmt("testKlass Address: %p", testKlassAddr);*/
|
||||
|
||||
auto testAddress2 = Il2cppUtils::GetMethodPointer("quaunity-ui.Runtime.dll", "Qua.UI",
|
||||
"I18nHelper", "SetUpI18n", 3);
|
||||
Log::InfoFmt("testAddress2 Address: %p", testAddress2);
|
||||
|
||||
// ADD_HOOK(HookMain::criWare, hookInstaller->LookupSymbol("_CRIWARE98F02F7C"));
|
||||
HookMain::StartHook();
|
||||
|
||||
/*
|
||||
const auto hookAddress = Il2cppJson::GetUnityBaseAddress() + Il2cppJson::GetIl2cppAddressMap()["il2cpp_init"];
|
||||
Log::InfoFmt("[Hook] s_baseAddress at %p, il2cpp_init at %p", Il2cppJson::GetUnityBaseAddress(), hookAddress);
|
||||
ADD_HOOK(HookMain::il2cpp_init, hookAddress); // TODO Il2cppAddress 在构造函数阶段是没有没初始化的*/
|
||||
// HookMain::StartHook();
|
||||
|
||||
Log::Info("Hook installed");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
#ifndef GAKUMAS_LOCALIFY_HOOK_H
|
||||
#define GAKUMAS_LOCALIFY_HOOK_H
|
||||
|
||||
#include <string>
|
||||
|
||||
namespace GakumasLocal::Hook
|
||||
{
|
||||
void Install();
|
||||
}
|
||||
|
||||
#endif //GAKUMAS_LOCALIFY_HOOK_H
|
||||
|
|
@ -0,0 +1,490 @@
|
|||
#pragma once
|
||||
#include "Log.h"
|
||||
#include <memory>
|
||||
#include <unordered_map>
|
||||
|
||||
#include "../il2cpp_dump/Il2cppJson.hpp"
|
||||
#include "../il2cpp_dump/il2cppTypes.hpp"
|
||||
|
||||
namespace Il2cppUtils {
|
||||
using namespace GakumasLocal;
|
||||
|
||||
struct Il2CppClassHead {
|
||||
// The following fields are always valid for a Il2CppClass structure
|
||||
const void* image;
|
||||
void* gc_desc;
|
||||
const char* name;
|
||||
const char* namespaze;
|
||||
};
|
||||
|
||||
struct Il2CppObject
|
||||
{
|
||||
union
|
||||
{
|
||||
void* klass;
|
||||
void* vtable;
|
||||
};
|
||||
void* monitor;
|
||||
};
|
||||
|
||||
enum Il2CppTypeEnum
|
||||
{
|
||||
IL2CPP_TYPE_END = 0x00, /* End of List */
|
||||
IL2CPP_TYPE_VOID = 0x01,
|
||||
IL2CPP_TYPE_BOOLEAN = 0x02,
|
||||
IL2CPP_TYPE_CHAR = 0x03,
|
||||
IL2CPP_TYPE_I1 = 0x04,
|
||||
IL2CPP_TYPE_U1 = 0x05,
|
||||
IL2CPP_TYPE_I2 = 0x06,
|
||||
IL2CPP_TYPE_U2 = 0x07,
|
||||
IL2CPP_TYPE_I4 = 0x08,
|
||||
IL2CPP_TYPE_U4 = 0x09,
|
||||
IL2CPP_TYPE_I8 = 0x0a,
|
||||
IL2CPP_TYPE_U8 = 0x0b,
|
||||
IL2CPP_TYPE_R4 = 0x0c,
|
||||
IL2CPP_TYPE_R8 = 0x0d,
|
||||
IL2CPP_TYPE_STRING = 0x0e,
|
||||
IL2CPP_TYPE_PTR = 0x0f,
|
||||
IL2CPP_TYPE_BYREF = 0x10,
|
||||
IL2CPP_TYPE_VALUETYPE = 0x11,
|
||||
IL2CPP_TYPE_CLASS = 0x12,
|
||||
IL2CPP_TYPE_VAR = 0x13,
|
||||
IL2CPP_TYPE_ARRAY = 0x14,
|
||||
IL2CPP_TYPE_GENERICINST = 0x15,
|
||||
IL2CPP_TYPE_TYPEDBYREF = 0x16,
|
||||
IL2CPP_TYPE_I = 0x18,
|
||||
IL2CPP_TYPE_U = 0x19,
|
||||
IL2CPP_TYPE_FNPTR = 0x1b,
|
||||
IL2CPP_TYPE_OBJECT = 0x1c,
|
||||
IL2CPP_TYPE_SZARRAY = 0x1d,
|
||||
IL2CPP_TYPE_MVAR = 0x1e,
|
||||
IL2CPP_TYPE_CMOD_REQD = 0x1f,
|
||||
IL2CPP_TYPE_CMOD_OPT = 0x20,
|
||||
IL2CPP_TYPE_INTERNAL = 0x21,
|
||||
|
||||
IL2CPP_TYPE_MODIFIER = 0x40,
|
||||
IL2CPP_TYPE_SENTINEL = 0x41,
|
||||
IL2CPP_TYPE_PINNED = 0x45,
|
||||
|
||||
IL2CPP_TYPE_ENUM = 0x55
|
||||
};
|
||||
|
||||
typedef struct Il2CppType
|
||||
{
|
||||
void* dummy;
|
||||
unsigned int attrs : 16;
|
||||
Il2CppTypeEnum type : 8;
|
||||
unsigned int num_mods : 6;
|
||||
unsigned int byref : 1;
|
||||
unsigned int pinned : 1;
|
||||
} Il2CppType;
|
||||
|
||||
struct Il2CppReflectionType
|
||||
{
|
||||
Il2CppObject object;
|
||||
const Il2CppType* type;
|
||||
};
|
||||
|
||||
struct Resolution_t {
|
||||
int width;
|
||||
int height;
|
||||
int herz;
|
||||
};
|
||||
|
||||
struct FieldInfo {
|
||||
const char* name;
|
||||
const Il2CppType* type;
|
||||
uintptr_t parent;
|
||||
int32_t offset;
|
||||
uint32_t token;
|
||||
};
|
||||
|
||||
struct MethodInfo {
|
||||
uintptr_t methodPointer;
|
||||
uintptr_t virtualMethodPointer;
|
||||
uintptr_t invoker_method;
|
||||
const char* name;
|
||||
uintptr_t klass;
|
||||
const Il2CppType* return_type;
|
||||
const void* parameters;
|
||||
uintptr_t methodDefinition;
|
||||
uintptr_t genericContainer;
|
||||
uint32_t token;
|
||||
uint16_t flags;
|
||||
uint16_t iflags;
|
||||
uint16_t slot;
|
||||
uint8_t parameters_count;
|
||||
uint8_t is_generic : 1;
|
||||
uint8_t is_inflated : 1;
|
||||
uint8_t wrapper_type : 1;
|
||||
uint8_t is_marshaled_from_native : 1;
|
||||
};
|
||||
|
||||
static Il2CppClassHead* get_class_from_instance(const void* instance) {
|
||||
#ifdef GKMS_IOS
|
||||
return static_cast<Il2CppClassHead*>(*static_cast<void* const*>(__builtin_assume_aligned(instance, alignof(void*))));
|
||||
#else
|
||||
return static_cast<Il2CppClassHead*>(*static_cast<void* const*>(std::assume_aligned<alignof(void*)>(instance)));
|
||||
#endif
|
||||
}
|
||||
|
||||
inline const void* il2cpp_method_get_return_type(const void* method_info_ptr) {
|
||||
if (!method_info_ptr) return nullptr;
|
||||
|
||||
#if defined(__aarch64__) || defined(__x86_64__) || defined(_M_X64)
|
||||
// 64位架构：偏移 0x20 (32 bytes)
|
||||
return (const void*)(*(uintptr_t*)((uintptr_t)method_info_ptr + 0x28));
|
||||
#else
|
||||
// 32位架构：偏移 0x10 (16 bytes)
|
||||
return (const void*)(*(uintptr_t*)((uintptr_t)method_info_ptr + 0x14));
|
||||
#endif
|
||||
}
|
||||
|
||||
inline MethodInfo* il2cpp_class_get_method_from_name(void* klass, const char* name, int argsCount)
|
||||
{
|
||||
// Log::InfoFmt("il2cpp_class_get_method_from_name: %s", name);
|
||||
auto ret = Il2cppJson::InvokeIl2cpp<MethodInfo*>("il2cpp_class_get_method_from_name", klass, name, argsCount);
|
||||
// Log::InfoFmt("il2cpp_class_get_method_from_name finished: %p", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
inline Il2cppJson::Class* GetClass(const std::string& assemblyName,
|
||||
const std::string& nameSpaceName,
|
||||
const std::string& className)
|
||||
{
|
||||
return Il2cppJson::GetClass(assemblyName, nameSpaceName, className);
|
||||
}
|
||||
|
||||
inline Il2CppClassHead* GetIl2cppClassFromName(const char* assemblyName, const char* nameSpaceName, const char* className) {
|
||||
Log::Info("GetMethodIl2cpp 0");
|
||||
static auto domain = Il2cppJson::InvokeIl2cpp<void*>("il2cpp_domain_get");
|
||||
if (!domain)
|
||||
{
|
||||
Log::ErrorFmt("GetMethodIl2cpp error: failed to get domain.");
|
||||
return nullptr;
|
||||
}
|
||||
auto assembly = Il2cppJson::InvokeIl2cpp<void*>("il2cpp_domain_assembly_open", domain, assemblyName);
|
||||
if (!assembly)
|
||||
{
|
||||
Log::ErrorFmt("GetMethodIl2cpp error: failed to get assembly: %s", assemblyName);
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// auto assembly = Il2cppJson::InvokeIl2cpp<void*>("il2cpp_domain_assembly_open+1", assemblyName);
|
||||
// UnityResolve::Invoke<void*>("il2cpp_thread_attach", domain);
|
||||
Log::Info("GetMethodIl2cpp 1");
|
||||
auto image = Il2cppJson::InvokeIl2cpp<void*>("il2cpp_assembly_get_image", assembly);
|
||||
if (!image) {
|
||||
Log::ErrorFmt("GetMethodIl2cpp error: assembly %s not found.", assemblyName);
|
||||
return nullptr;
|
||||
}
|
||||
Log::InfoFmt("GetMethodIl2cpp 2, assembly: %p, image: %p, nameSpace: %s, class: %s", assembly, image, nameSpaceName, className);
|
||||
auto klass = Il2cppJson::InvokeIl2cpp<Il2CppClassHead*>("il2cpp_class_from_name", image, nameSpaceName, className);
|
||||
Log::Info("GetMethodIl2cpp 3");
|
||||
if (!klass) {
|
||||
Log::ErrorFmt("GetMethodIl2cpp error: Class %s::%s not found.", nameSpaceName, className);
|
||||
return nullptr;
|
||||
}
|
||||
return klass;
|
||||
}
|
||||
|
||||
inline MethodInfo* GetMethodIl2cpp(const char* assemblyName, const char* nameSpaceName,
|
||||
const char* className, const char* methodName, const int argsCount) {
|
||||
auto klass = GetIl2cppClassFromName(assemblyName, nameSpaceName, className);
|
||||
if (!klass) return nullptr;
|
||||
Log::Info("GetMethodIl2cpp 4");
|
||||
auto ret = Il2cppJson::InvokeIl2cpp<MethodInfo*>("il2cpp_class_get_method_from_name", klass, methodName, argsCount);
|
||||
Log::Info("GetMethodIl2cpp 5");
|
||||
if (!ret) {
|
||||
Log::ErrorFmt("GetMethodIl2cpp error: method %s::%s.%s not found.", nameSpaceName, className, methodName);
|
||||
return nullptr;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
inline Il2cppJson::Method* GetMethod(const char* assemblyName,
|
||||
const char* nameSpaceName,
|
||||
const char* className,
|
||||
const char* methodName,
|
||||
// const std::vector<std::string>& args = {})
|
||||
const int argsCount)
|
||||
{
|
||||
return Il2cppJson::GetMethod(assemblyName, nameSpaceName, className, methodName, {});
|
||||
/*
|
||||
const auto method = GetMethodIl2cpp(assemblyName, nameSpaceName, className, methodName, argsCount);
|
||||
if (!method) return std::nullopt;
|
||||
|
||||
return Il2cppJson::Method {
|
||||
methodName, {}, argsCount, method->methodPointer
|
||||
};*/
|
||||
}
|
||||
|
||||
inline Il2cppJson::Method* GetMethod(const char* assemblyName,
|
||||
const char* nameSpaceName,
|
||||
const char* className,
|
||||
const char* methodName,
|
||||
const std::vector<std::string>& args = {})
|
||||
{
|
||||
return Il2cppJson::GetMethod(assemblyName, nameSpaceName, className, methodName, args);
|
||||
}
|
||||
|
||||
inline void* GetMethodPointer(const char* assemblyName,
|
||||
const char* nameSpaceName,
|
||||
const char* className,
|
||||
const char* methodName,
|
||||
// const std::vector<std::string>& args = {})
|
||||
const int argsCount)
|
||||
{
|
||||
const auto method = GetMethod(assemblyName, nameSpaceName, className, methodName, argsCount);
|
||||
if (!method) return nullptr;
|
||||
return reinterpret_cast<void*>(method->address);
|
||||
}
|
||||
|
||||
inline void* GetMethodPointer(const char* assemblyName,
|
||||
const char* nameSpaceName,
|
||||
const char* className,
|
||||
const char* methodName,
|
||||
const std::vector<std::string>& args = {})
|
||||
{
|
||||
const auto method = GetMethod(assemblyName, nameSpaceName, className, methodName, args);
|
||||
if (!method) return nullptr;
|
||||
return reinterpret_cast<void*>(method->address);
|
||||
}
|
||||
|
||||
template <typename RType>
|
||||
static auto ClassGetFieldValue(void* obj, FieldInfo* field) -> RType {
|
||||
return *reinterpret_cast<RType*>(reinterpret_cast<uintptr_t>(obj) + field->offset);
|
||||
}
|
||||
|
||||
template <typename RType>
|
||||
static auto ClassSetFieldValue(void* obj, FieldInfo* field, RType value) -> void {
|
||||
*reinterpret_cast<RType*>(reinterpret_cast<uintptr_t>(obj) + field->offset) = value;
|
||||
}
|
||||
|
||||
static void* get_system_class_from_reflection_type_str(const char* typeStr, const char* assemblyName = "mscorlib") {
|
||||
using Il2CppString = Il2cppTypes::String;
|
||||
|
||||
static auto assemblyLoad = reinterpret_cast<void* (*)(Il2CppString*)>(
|
||||
GetMethodPointer("mscorlib.dll", "System.Reflection",
|
||||
"Assembly", "Load", {"*"})
|
||||
);
|
||||
static auto assemblyGetType = reinterpret_cast<Il2CppReflectionType * (*)(void*, Il2CppString*)>(
|
||||
GetMethodPointer("mscorlib.dll", "System.Reflection",
|
||||
"Assembly", "GetType", {"*"})
|
||||
);
|
||||
|
||||
static auto reflectionAssembly = assemblyLoad(Il2CppString::New(assemblyName));
|
||||
auto reflectionType = assemblyGetType(reflectionAssembly, Il2CppString::New(typeStr));
|
||||
return Il2cppJson::InvokeIl2cpp<void*>("il2cpp_class_from_system_type", reflectionType);
|
||||
}
|
||||
|
||||
inline bool il2cpp_class_is_enum(int64_t a1)
|
||||
{
|
||||
return (*(__uint8_t *)(a1 + 309) >> 2) & 1;
|
||||
}
|
||||
|
||||
static std::unordered_map<std::string, std::unordered_map<int, std::string>> enumToValueMapCache{};
|
||||
static std::unordered_map<int, std::string> EnumToValueMap(Il2CppClassHead* enumClass, bool useCache) {
|
||||
std::unordered_map<int, std::string> ret{};
|
||||
// auto isEnum = UnityResolve::Invoke<bool>("il2cpp_class_is_enum", enumClass);
|
||||
auto isEnum = Il2cppUtils::il2cpp_class_is_enum(reinterpret_cast<int64_t>(static_cast<void*>(enumClass)));
|
||||
|
||||
if (isEnum) {
|
||||
Il2cppUtils::FieldInfo* field = nullptr;
|
||||
void* iter = nullptr;
|
||||
|
||||
std::string cacheName = std::string(enumClass->namespaze) + "::" + enumClass->name;
|
||||
if (useCache) {
|
||||
if (auto it = enumToValueMapCache.find(cacheName); it != enumToValueMapCache.end()) {
|
||||
return it->second;
|
||||
}
|
||||
}
|
||||
|
||||
while ((field = Il2cppJson::InvokeIl2cpp<Il2cppUtils::FieldInfo*>("il2cpp_class_get_fields", enumClass, &iter))) {
|
||||
// Log::DebugFmt("field: %s, off: %d", field->name, field->offset);
|
||||
if (field->offset > 0) continue; // 非 static
|
||||
if (strcmp(field->name, "value__") == 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
int value;
|
||||
Il2cppJson::InvokeIl2cpp<void>("il2cpp_field_static_get_value_0+1", field, &value, 0LL);
|
||||
// Log::DebugFmt("returnClass: %s - %s: 0x%x", enumClass->name, field->name, value);
|
||||
std::string itemName = std::string(enumClass->name) + "_" + field->name;
|
||||
ret.emplace(value, std::move(itemName));
|
||||
}
|
||||
|
||||
if (useCache) {
|
||||
enumToValueMapCache.emplace(std::move(cacheName), ret);
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
namespace Tools {
|
||||
|
||||
template <typename T = void*>
|
||||
class CSListEditor {
|
||||
public:
|
||||
CSListEditor(void* list) {
|
||||
list_klass = get_class_from_instance(list);
|
||||
lst = list;
|
||||
|
||||
lst_get_Count_method = il2cpp_class_get_method_from_name(list_klass, "get_Count", 0);
|
||||
lst_get_Item_method = il2cpp_class_get_method_from_name(list_klass, "get_Item", 1);
|
||||
lst_set_Item_method = il2cpp_class_get_method_from_name(list_klass, "set_Item", 2);
|
||||
lst_Add_method = il2cpp_class_get_method_from_name(list_klass, "Add", 1);
|
||||
lst_Contains_method = il2cpp_class_get_method_from_name(list_klass, "Contains", 1);
|
||||
|
||||
lst_get_Count = reinterpret_cast<lst_get_Count_t>(lst_get_Count_method->methodPointer);
|
||||
lst_get_Item = reinterpret_cast<lst_get_Item_t>(lst_get_Item_method->methodPointer);
|
||||
lst_set_Item = reinterpret_cast<lst_set_Item_t>(lst_set_Item_method->methodPointer);
|
||||
lst_Add = reinterpret_cast<lst_Add_t>(lst_Add_method->methodPointer);
|
||||
lst_Contains = reinterpret_cast<lst_Contains_t>(lst_Contains_method->methodPointer);
|
||||
}
|
||||
|
||||
void Add(T value) {
|
||||
lst_Add(lst, value, lst_Add_method);
|
||||
}
|
||||
|
||||
bool Contains(T value) {
|
||||
return lst_Contains(lst, value, lst_Contains_method);
|
||||
}
|
||||
|
||||
T get_Item(int index) {
|
||||
return lst_get_Item(lst, index, lst_get_Item_method);
|
||||
}
|
||||
|
||||
void set_Item(int index, T value) {
|
||||
return lst_set_Item(lst, index, value, lst_set_Item_method);
|
||||
}
|
||||
|
||||
int get_Count() {
|
||||
return lst_get_Count(lst, lst_get_Count_method);
|
||||
}
|
||||
|
||||
T operator[] (int key) {
|
||||
return get_Item(key);
|
||||
}
|
||||
|
||||
class Iterator {
|
||||
public:
|
||||
Iterator(CSListEditor<T>* editor, int index) : editor(editor), index(index) {}
|
||||
|
||||
T operator*() const {
|
||||
return editor->get_Item(index);
|
||||
}
|
||||
|
||||
Iterator& operator++() {
|
||||
++index;
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool operator!=(const Iterator& other) const {
|
||||
return index != other.index;
|
||||
}
|
||||
|
||||
private:
|
||||
CSListEditor<T>* editor;
|
||||
int index;
|
||||
};
|
||||
|
||||
Iterator begin() {
|
||||
return Iterator(this, 0);
|
||||
}
|
||||
|
||||
Iterator end() {
|
||||
return Iterator(this, get_Count());
|
||||
}
|
||||
|
||||
void* lst;
|
||||
void* list_klass;
|
||||
private:
|
||||
typedef T(*lst_get_Item_t)(void*, int, void* mtd);
|
||||
typedef void(*lst_Add_t)(void*, T, void* mtd);
|
||||
typedef void(*lst_set_Item_t)(void*, int, T, void* mtd);
|
||||
typedef int(*lst_get_Count_t)(void*, void* mtd);
|
||||
typedef bool(*lst_Contains_t)(void*, T, void* mtd);
|
||||
|
||||
MethodInfo* lst_get_Item_method;
|
||||
MethodInfo* lst_Add_method;
|
||||
MethodInfo* lst_get_Count_method;
|
||||
MethodInfo* lst_set_Item_method;
|
||||
MethodInfo* lst_Contains_method;
|
||||
|
||||
lst_get_Item_t lst_get_Item;
|
||||
lst_set_Item_t lst_set_Item;
|
||||
lst_Add_t lst_Add;
|
||||
lst_get_Count_t lst_get_Count;
|
||||
lst_Contains_t lst_Contains;
|
||||
};
|
||||
|
||||
|
||||
template <typename KT = void*, typename VT = void*>
|
||||
class CSDictEditor {
|
||||
public:
|
||||
// @param dict: Dictionary instance.
|
||||
// @param dictTypeStr: Reflection type. eg: "System.Collections.Generic.Dictionary`2[System.Int32, System.Int32]"
|
||||
// CSDictEditor(void* dict, const char* dictTypeStr) {
|
||||
// dic_klass = Il2cppUtils::get_system_class_from_reflection_type_str(dictTypeStr);
|
||||
// initDict(dict);
|
||||
// }
|
||||
|
||||
CSDictEditor(void* dict) {
|
||||
dic_klass = get_class_from_instance(dict);
|
||||
initDict(dict);
|
||||
}
|
||||
|
||||
CSDictEditor(void* dict, void* dicClass) {
|
||||
dic_klass = dicClass;
|
||||
initDict(dict);
|
||||
}
|
||||
|
||||
void Add(KT key, VT value) {
|
||||
dic_Add(dict, key, value, Add_method);
|
||||
}
|
||||
|
||||
bool ContainsKey(KT key) {
|
||||
return dic_containsKey(dict, key, ContainsKey_method);
|
||||
}
|
||||
|
||||
VT get_Item(KT key) {
|
||||
return dic_get_Item(dict, key, get_Item_method);
|
||||
}
|
||||
|
||||
VT operator[] (KT key) {
|
||||
return get_Item(key);
|
||||
}
|
||||
|
||||
void* dict;
|
||||
void* dic_klass;
|
||||
|
||||
private:
|
||||
void initDict(void* dict) {
|
||||
// dic_klass = dicClass;
|
||||
this->dict = dict;
|
||||
|
||||
get_Item_method = Il2cppJson::InvokeIl2cpp<MethodInfo*>("il2cpp_class_get_method_from_name", "get_Item", 1);
|
||||
Add_method = Il2cppJson::InvokeIl2cpp<MethodInfo*>("il2cpp_class_get_method_from_name", "Add", 2);
|
||||
ContainsKey_method = Il2cppJson::InvokeIl2cpp<MethodInfo*>("il2cpp_class_get_method_from_name", "ContainsKey", 1);
|
||||
|
||||
dic_get_Item = (dic_get_Item_t)get_Item_method->methodPointer;
|
||||
dic_Add = (dic_Add_t)Add_method->methodPointer;
|
||||
dic_containsKey = (dic_containsKey_t)ContainsKey_method->methodPointer;
|
||||
}
|
||||
|
||||
typedef VT(*dic_get_Item_t)(void*, KT, void* mtd);
|
||||
typedef VT(*dic_Add_t)(void*, KT, VT, void* mtd);
|
||||
typedef VT(*dic_containsKey_t)(void*, KT, void* mtd);
|
||||
|
||||
CSDictEditor();
|
||||
MethodInfo* get_Item_method;
|
||||
MethodInfo* Add_method;
|
||||
MethodInfo* ContainsKey_method;
|
||||
dic_get_Item_t dic_get_Item;
|
||||
dic_Add_t dic_Add;
|
||||
dic_containsKey_t dic_containsKey;
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,635 @@
|
|||
#include "Local.h"
|
||||
#include "Log.h"
|
||||
#include "Plugin.h"
|
||||
#include "config/Config.hpp"
|
||||
#include <filesystem>
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
#include <unordered_map>
|
||||
#include <unordered_set>
|
||||
#include <nlohmann/json.hpp>
|
||||
#include <thread>
|
||||
#include <regex>
|
||||
#include <string>
|
||||
#include <cctype>
|
||||
#include <algorithm>
|
||||
#include "BaseDefine.h"
|
||||
#include "string_parser/StringParser.hpp"
|
||||
|
||||
// #include "cpprest/details/http_helpers.h"
|
||||
|
||||
|
||||
namespace GakumasLocal::Local {
|
||||
std::unordered_map<std::string, std::string> i18nData{};
|
||||
std::unordered_map<std::string, std::string> i18nDumpData{};
|
||||
std::unordered_map<std::string, std::string> genericText{};
|
||||
std::unordered_map<std::string, std::string> genericSplitText{};
|
||||
std::unordered_map<std::string, std::string> genericFmtText{};
|
||||
std::vector<std::string> genericTextDumpData{};
|
||||
std::vector<std::string> genericSplittedDumpData{};
|
||||
std::vector<std::string> genericOrigTextDumpData{};
|
||||
std::vector<std::string> genericFmtTextDumpData{};
|
||||
|
||||
std::unordered_set<std::string> translatedText{};
|
||||
int genericDumpFileIndex = 0;
|
||||
const std::string splitTextPrefix = "[__split__]";
|
||||
|
||||
std::filesystem::path GetBasePath() {
|
||||
return Plugin::GetInstance().GetHookInstaller()->localizationFilesDir;
|
||||
}
|
||||
|
||||
bool isAllSpace(const std::string& str) {
|
||||
return std::all_of(str.begin(), str.end(), [](unsigned char c) {
|
||||
return std::isspace(c);
|
||||
});
|
||||
}
|
||||
|
||||
std::string trim(const std::string& str) {
|
||||
auto is_not_space = [](char ch) { return !std::isspace(static_cast<unsigned char>(ch)); };
|
||||
auto start = std::find_if(str.begin(), str.end(), is_not_space);
|
||||
auto end = std::find_if(str.rbegin(), str.rend(), is_not_space).base();
|
||||
|
||||
if (start < end) {
|
||||
return {start, end};
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
std::string findInMapIgnoreSpace(const std::string& key, const std::unordered_map<std::string, std::string>& searchMap) {
|
||||
auto is_space = [](char ch) { return std::isspace(static_cast<unsigned char>(ch)); };
|
||||
auto front = std::find_if_not(key.begin(), key.end(), is_space);
|
||||
auto back = std::find_if_not(key.rbegin(), key.rend(), is_space).base();
|
||||
|
||||
std::string prefix(key.begin(), front);
|
||||
std::string suffix(back, key.end());
|
||||
|
||||
std::string trimmedKey = trim(key);
|
||||
if ( auto it = searchMap.find(trimmedKey); it != searchMap.end()) {
|
||||
return prefix + it->second + suffix;
|
||||
}
|
||||
else {
|
||||
return "";
|
||||
}
|
||||
}
|
||||
|
||||
enum class DumpStrStat {
|
||||
DEFAULT = 0,
|
||||
SPLITTABLE_ORIG = 1,
|
||||
SPLITTED = 2,
|
||||
FMT = 3
|
||||
};
|
||||
|
||||
enum class SplitTagsTranslationStat {
|
||||
NO_TRANS,
|
||||
PART_TRANS,
|
||||
FULL_TRANS,
|
||||
NO_SPLIT,
|
||||
NO_SPLIT_AND_EMPTY
|
||||
};
|
||||
|
||||
void LoadJsonDataToMap(const std::filesystem::path& filePath, std::unordered_map<std::string, std::string>& dict,
|
||||
const bool insertToTranslated = false, const bool needClearDict = true,
|
||||
const bool needCheckSplitPrefix = false) {
|
||||
if (!exists(filePath)) return;
|
||||
try {
|
||||
if (needClearDict) {
|
||||
dict.clear();
|
||||
}
|
||||
std::ifstream file(filePath);
|
||||
if (!file.is_open()) {
|
||||
Log::ErrorFmt("Load %s failed.\n", filePath.string().c_str());
|
||||
return;
|
||||
}
|
||||
std::string fileContent((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
|
||||
file.close();
|
||||
auto fileData = nlohmann::json::parse(fileContent);
|
||||
for (auto& i : fileData.items()) {
|
||||
const auto& key = i.key();
|
||||
const std::string value = i.value();
|
||||
if (needCheckSplitPrefix && key.starts_with(splitTextPrefix) && value.starts_with(splitTextPrefix)) {
|
||||
static const auto splitTextPrefixLength = splitTextPrefix.size();
|
||||
const auto splitValue = value.substr(splitTextPrefixLength);
|
||||
genericSplitText[key.substr(splitTextPrefixLength)] = splitValue;
|
||||
if (insertToTranslated) translatedText.emplace(splitValue);
|
||||
}
|
||||
else {
|
||||
dict[key] = value;
|
||||
if (insertToTranslated) translatedText.emplace(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (std::exception& e) {
|
||||
Log::ErrorFmt("Load %s failed: %s\n", filePath.string().c_str(), e.what());
|
||||
}
|
||||
}
|
||||
|
||||
void DumpMapDataToJson(const std::filesystem::path& dumpBasePath, const std::filesystem::path& fileName,
|
||||
const std::unordered_map<std::string, std::string>& dict) {
|
||||
const auto dumpFilePath = dumpBasePath / fileName;
|
||||
try {
|
||||
if (!is_directory(dumpBasePath)) {
|
||||
std::filesystem::create_directories(dumpBasePath);
|
||||
}
|
||||
if (!std::filesystem::exists(dumpFilePath)) {
|
||||
std::ofstream dumpWriteLrcFile(dumpFilePath, std::ofstream::out);
|
||||
dumpWriteLrcFile << "{}";
|
||||
dumpWriteLrcFile.close();
|
||||
}
|
||||
|
||||
std::ifstream dumpLrcFile(dumpFilePath);
|
||||
std::string fileContent((std::istreambuf_iterator<char>(dumpLrcFile)), std::istreambuf_iterator<char>());
|
||||
dumpLrcFile.close();
|
||||
auto fileData = nlohmann::ordered_json::parse(fileContent);
|
||||
for (const auto& i : dict) {
|
||||
fileData[i.first] = i.second;
|
||||
}
|
||||
const auto newStr = fileData.dump(4, 32, false);
|
||||
std::ofstream dumpWriteLrcFile(dumpFilePath, std::ofstream::out);
|
||||
dumpWriteLrcFile << newStr.c_str();
|
||||
dumpWriteLrcFile.close();
|
||||
}
|
||||
catch (std::exception& e) {
|
||||
Log::ErrorFmt("DumpMapDataToJson %s failed: %s", dumpFilePath.c_str(), e.what());
|
||||
}
|
||||
}
|
||||
|
||||
void DumpVectorDataToJson(const std::filesystem::path& dumpBasePath, const std::filesystem::path& fileName,
|
||||
const std::vector<std::string>& vec, const std::string& prefix = "") {
|
||||
const auto dumpFilePath = dumpBasePath / fileName;
|
||||
try {
|
||||
if (!is_directory(dumpBasePath)) {
|
||||
std::filesystem::create_directories(dumpBasePath);
|
||||
}
|
||||
if (!std::filesystem::exists(dumpFilePath)) {
|
||||
std::ofstream dumpWriteLrcFile(dumpFilePath, std::ofstream::out);
|
||||
dumpWriteLrcFile << "{}";
|
||||
dumpWriteLrcFile.close();
|
||||
}
|
||||
|
||||
std::ifstream dumpLrcFile(dumpFilePath);
|
||||
std::string fileContent((std::istreambuf_iterator<char>(dumpLrcFile)), std::istreambuf_iterator<char>());
|
||||
dumpLrcFile.close();
|
||||
auto fileData = nlohmann::ordered_json::parse(fileContent);
|
||||
for (const auto& i : vec) {
|
||||
if (!prefix.empty()) {
|
||||
fileData[prefix + i] = prefix + i;
|
||||
}
|
||||
else {
|
||||
fileData[i] = i;
|
||||
}
|
||||
}
|
||||
const auto newStr = fileData.dump(4, 32, false);
|
||||
std::ofstream dumpWriteLrcFile(dumpFilePath, std::ofstream::out);
|
||||
dumpWriteLrcFile << newStr.c_str();
|
||||
dumpWriteLrcFile.close();
|
||||
}
|
||||
catch (std::exception& e) {
|
||||
Log::ErrorFmt("DumpVectorDataToJson %s failed: %s", dumpFilePath.c_str(), e.what());
|
||||
}
|
||||
}
|
||||
|
||||
std::string to_lower(const std::string& str) {
|
||||
std::string lower_str = str;
|
||||
std::transform(lower_str.begin(), lower_str.end(), lower_str.begin(), ::tolower);
|
||||
return lower_str;
|
||||
}
|
||||
|
||||
bool IsPureStringValue(const std::string& str) {
|
||||
static std::unordered_set<char> notDeeds = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':',
|
||||
'/', ' ', '.', '%', ',', '+', '-', 'x', '\n'};
|
||||
for (const auto& i : str) {
|
||||
if (!notDeeds.contains(i)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
std::vector<std::string> SplitByTags(const std::string& origText) {
|
||||
static const std::regex tagsRe("<.*?>(.*?)</.*?>");
|
||||
std::string text = origText;
|
||||
std::smatch match;
|
||||
|
||||
std::vector<std::string> ret{};
|
||||
|
||||
std::string lastSuffix;
|
||||
while (std::regex_search(text, match, tagsRe)) {
|
||||
const auto tagValue = match[1].str();
|
||||
if (IsPureStringValue(tagValue)) {
|
||||
ret.push_back(match.prefix().str());
|
||||
lastSuffix = match.suffix().str();
|
||||
}
|
||||
text = match.suffix().str();
|
||||
}
|
||||
if (!lastSuffix.empty()) {
|
||||
ret.push_back(lastSuffix);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
void ProcessGenericTextLabels() {
|
||||
std::unordered_map<std::string, std::string> appendsText{};
|
||||
|
||||
for (const auto& i : genericText) {
|
||||
const auto origContents = SplitByTags(i.first);
|
||||
if (origContents.empty()) {
|
||||
continue;
|
||||
}
|
||||
const auto translatedContents = SplitByTags(i.second);
|
||||
if (origContents.size() == translatedContents.size()) {
|
||||
for (size_t i = 0; i < origContents.size(); ++i) {
|
||||
appendsText.emplace(origContents[i], translatedContents[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
genericText.insert(appendsText.begin(), appendsText.end());
|
||||
}
|
||||
|
||||
bool ReplaceString(std::string* str, const std::string& oldSubstr, const std::string& newSubstr) {
|
||||
size_t pos = str->find(oldSubstr);
|
||||
if (pos != std::string::npos) {
|
||||
str->replace(pos, oldSubstr.length(), newSubstr);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool GetSplitTagsTranslation(const std::string& origText, std::string* newText, std::vector<std::string>& unTransResultRet) {
|
||||
if (origText.find('<') == std::string::npos) return false;
|
||||
const auto splitResult = SplitByTags(origText);
|
||||
if (splitResult.empty()) return false;
|
||||
|
||||
*newText = origText;
|
||||
bool ret = true;
|
||||
for (const auto& i : splitResult) {
|
||||
if (const auto iter = genericText.find(i); iter != genericText.end()) {
|
||||
ReplaceString(newText, i, iter->second);
|
||||
}
|
||||
else {
|
||||
unTransResultRet.emplace_back(i);
|
||||
ret = false;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void ReplaceNumberComma(std::string* orig) {
|
||||
if (orig->find("，") == std::string::npos) return;
|
||||
std::string newStr = *orig;
|
||||
ReplaceString(&newStr, "，", ",");
|
||||
if (IsPureStringValue(newStr)) {
|
||||
*orig = newStr;
|
||||
}
|
||||
}
|
||||
|
||||
SplitTagsTranslationStat GetSplitTagsTranslationFull(const std::string& origTextIn, std::string* newText, std::vector<std::string>& unTransResultRet) {
|
||||
// static const std::u16string splitFlags = u"0123456789+＋-－%％【】.";
|
||||
static const std::unordered_set<char16_t> splitFlags = {u'0', u'1', u'2', u'3', u'4', u'5',
|
||||
u'6', u'7', u'8', u'9', u'+', u'＋',
|
||||
u'-', u'－', u'%', u'％', u'【', u'】',
|
||||
u'.', u':', u'：', u'×'};
|
||||
|
||||
const auto origText = Misc::ToUTF16(origTextIn);
|
||||
bool isInTag = false;
|
||||
std::vector<std::string> waitingReplaceTexts{};
|
||||
|
||||
std::u16string currentWaitingReplaceText;
|
||||
|
||||
#ifdef GKMS_WINDOWS
|
||||
#define checkCurrentWaitingReplaceTextAndClear() \
|
||||
if (!currentWaitingReplaceText.empty()) { \
|
||||
auto trimmed = trim(Misc::ToUTF8(currentWaitingReplaceText)); \
|
||||
waitingReplaceTexts.push_back(trimmed); \
|
||||
currentWaitingReplaceText.clear(); }
|
||||
#else
|
||||
#define checkCurrentWaitingReplaceTextAndClear() \
|
||||
if (!currentWaitingReplaceText.empty()) { \
|
||||
waitingReplaceTexts.push_back(Misc::ToUTF8(currentWaitingReplaceText)); \
|
||||
currentWaitingReplaceText.clear(); }
|
||||
#endif
|
||||
|
||||
for (char16_t currChar : origText) {
|
||||
if (currChar == u'<') {
|
||||
isInTag = true;
|
||||
}
|
||||
if (currChar == u'>') {
|
||||
isInTag = false;
|
||||
checkCurrentWaitingReplaceTextAndClear()
|
||||
continue;
|
||||
}
|
||||
if (isInTag) {
|
||||
checkCurrentWaitingReplaceTextAndClear()
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!splitFlags.contains(currChar)) {
|
||||
currentWaitingReplaceText.push_back(currChar);
|
||||
}
|
||||
else {
|
||||
checkCurrentWaitingReplaceTextAndClear()
|
||||
}
|
||||
}
|
||||
if (waitingReplaceTexts.empty()) {
|
||||
if (currentWaitingReplaceText.empty()) {
|
||||
return SplitTagsTranslationStat::NO_SPLIT_AND_EMPTY;
|
||||
}
|
||||
else {
|
||||
if (!(!origText.empty() && splitFlags.contains(origText[0]))) { // 开头为特殊符号或数字
|
||||
return SplitTagsTranslationStat::NO_SPLIT;
|
||||
}
|
||||
}
|
||||
}
|
||||
checkCurrentWaitingReplaceTextAndClear()
|
||||
|
||||
*newText = origTextIn;
|
||||
SplitTagsTranslationStat ret;
|
||||
bool hasTrans = false;
|
||||
bool hasNotTrans = false;
|
||||
if (!waitingReplaceTexts.empty()) {
|
||||
for (const auto& i : waitingReplaceTexts) {
|
||||
if (isAllSpace(i)) continue;
|
||||
std::string searchResult = findInMapIgnoreSpace(i, genericSplitText);
|
||||
if (!searchResult.empty()) {
|
||||
ReplaceNumberComma(&searchResult);
|
||||
ReplaceString(newText, i, searchResult);
|
||||
hasTrans = true;
|
||||
}
|
||||
else {
|
||||
unTransResultRet.emplace_back(trim(i));
|
||||
hasNotTrans = true;
|
||||
}
|
||||
}
|
||||
if (hasTrans && hasNotTrans) {
|
||||
ret = SplitTagsTranslationStat::PART_TRANS;
|
||||
}
|
||||
else if (hasTrans && !hasNotTrans) {
|
||||
ret = SplitTagsTranslationStat::FULL_TRANS;
|
||||
}
|
||||
else {
|
||||
ret = SplitTagsTranslationStat::NO_TRANS;
|
||||
}
|
||||
}
|
||||
else {
|
||||
ret = SplitTagsTranslationStat::NO_TRANS;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void LoadData() {
|
||||
static auto localizationFile = GetBasePath() / "local-files" / "localization.json";
|
||||
static auto genericFile = GetBasePath() / "local-files" / "generic.json";
|
||||
static auto genericSplitFile = GetBasePath() / "local-files" / "generic.split.json";
|
||||
static auto genericDir = GetBasePath() / "local-files" / "genericTrans";
|
||||
|
||||
if (!std::filesystem::is_regular_file(localizationFile)) {
|
||||
Log::ErrorFmt("localizationFile: %s not found.", localizationFile.c_str());
|
||||
return;
|
||||
}
|
||||
LoadJsonDataToMap(localizationFile, i18nData, true);
|
||||
Log::InfoFmt("%ld localization items loaded.", i18nData.size());
|
||||
|
||||
LoadJsonDataToMap(genericFile, genericText, true, true, true);
|
||||
genericSplitText.clear();
|
||||
genericFmtText.clear();
|
||||
LoadJsonDataToMap(genericSplitFile, genericSplitText, true, true, true);
|
||||
if (std::filesystem::exists(genericDir) || std::filesystem::is_directory(genericDir)) {
|
||||
for (const auto& entry : std::filesystem::recursive_directory_iterator(genericDir)) {
|
||||
if (std::filesystem::is_regular_file(entry.path())) {
|
||||
const auto& currFile = entry.path();
|
||||
if (to_lower(currFile.extension().string()) == ".json") {
|
||||
if (currFile.filename().string().ends_with(".split.json")) { // split text file
|
||||
LoadJsonDataToMap(currFile, genericSplitText, true, false, true);
|
||||
}
|
||||
if (currFile.filename().string().ends_with(".fmt.json")) { // fmt text file
|
||||
LoadJsonDataToMap(currFile, genericFmtText, true, false, false);
|
||||
}
|
||||
else {
|
||||
LoadJsonDataToMap(currFile, genericText, true, false, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
ProcessGenericTextLabels();
|
||||
Log::InfoFmt("%ld generic text items loaded.", genericText.size());
|
||||
|
||||
static auto dumpBasePath = GetBasePath() / "dump-files";
|
||||
static auto dumpFilePath = dumpBasePath / "localization.json";
|
||||
LoadJsonDataToMap(dumpFilePath, i18nDumpData);
|
||||
}
|
||||
|
||||
bool GetI18n(const std::string& key, std::string* ret) {
|
||||
if (const auto iter = i18nData.find(key); iter != i18nData.end()) {
|
||||
*ret = iter->second;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool inDump = false;
|
||||
void DumpI18nItem(const std::string& key, const std::string& value) {
|
||||
if (!Config::dumpText) return;
|
||||
if (i18nDumpData.contains(key)) return;
|
||||
i18nDumpData[key] = value;
|
||||
Log::DebugFmt("DumpI18nItem: %s - %s", key.c_str(), value.c_str());
|
||||
|
||||
static auto dumpBasePath = GetBasePath() / "dump-files";
|
||||
|
||||
if (inDump) return;
|
||||
inDump = true;
|
||||
std::thread([](){
|
||||
std::this_thread::sleep_for(std::chrono::seconds(5));
|
||||
DumpMapDataToJson(dumpBasePath, "localization.json", i18nDumpData);
|
||||
inDump = false;
|
||||
}).detach();
|
||||
}
|
||||
|
||||
std::string readFileToString(const std::string& filename) {
|
||||
std::ifstream file(filename);
|
||||
if (!file.is_open()) {
|
||||
throw std::exception();
|
||||
}
|
||||
std::string content((std::istreambuf_iterator<char>(file)),
|
||||
(std::istreambuf_iterator<char>()));
|
||||
file.close();
|
||||
return content;
|
||||
}
|
||||
|
||||
bool GetResourceText(const std::string& name, std::string* ret) {
|
||||
static std::filesystem::path basePath = GetBasePath();
|
||||
|
||||
try {
|
||||
const auto targetFilePath = basePath / "local-files" / "resource" / name;
|
||||
// Log::DebugFmt("GetResourceText: %s", targetFilePath.c_str());
|
||||
if (exists(targetFilePath)) {
|
||||
auto readStr = readFileToString(targetFilePath.string());
|
||||
*ret = readStr;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
catch (std::exception& e) {
|
||||
Log::ErrorFmt("read file: %s failed.", name.c_str());
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
std::string GetDumpGenericFileName(DumpStrStat stat = DumpStrStat::DEFAULT) {
|
||||
if (stat == DumpStrStat::SPLITTABLE_ORIG) {
|
||||
if (genericDumpFileIndex == 0) return "generic_orig.json";
|
||||
return Log::StringFormat("generic_orig_%d.json", genericDumpFileIndex);
|
||||
}
|
||||
else if (stat == DumpStrStat::FMT) {
|
||||
if (genericDumpFileIndex == 0) return "generic.fmt.json";
|
||||
return Log::StringFormat("generic_%d.fmt.json", genericDumpFileIndex);
|
||||
}
|
||||
else {
|
||||
if (genericDumpFileIndex == 0) return "generic.json";
|
||||
return Log::StringFormat("generic_%d.json", genericDumpFileIndex);
|
||||
}
|
||||
}
|
||||
|
||||
bool inDumpGeneric = false;
|
||||
void DumpGenericText(const std::string& origText, DumpStrStat stat = DumpStrStat::DEFAULT) {
|
||||
if (translatedText.contains(origText)) return;
|
||||
|
||||
std::array<std::reference_wrapper<std::vector<std::string>>, 4> targets = {
|
||||
genericTextDumpData,
|
||||
genericOrigTextDumpData,
|
||||
genericSplittedDumpData,
|
||||
genericFmtTextDumpData
|
||||
};
|
||||
|
||||
auto& appendTarget = targets[static_cast<int>(stat)].get();
|
||||
|
||||
if (std::find(appendTarget.begin(), appendTarget.end(), origText) != appendTarget.end()) {
|
||||
return;
|
||||
}
|
||||
if (IsPureStringValue(origText)) return;
|
||||
|
||||
appendTarget.push_back(origText);
|
||||
static auto dumpBasePath = GetBasePath() / "dump-files";
|
||||
|
||||
if (inDumpGeneric) return;
|
||||
inDumpGeneric = true;
|
||||
std::thread([](){
|
||||
std::this_thread::sleep_for(std::chrono::seconds(5));
|
||||
DumpVectorDataToJson(dumpBasePath, GetDumpGenericFileName(DumpStrStat::DEFAULT), genericTextDumpData);
|
||||
DumpVectorDataToJson(dumpBasePath, GetDumpGenericFileName(DumpStrStat::SPLITTABLE_ORIG), genericOrigTextDumpData);
|
||||
DumpVectorDataToJson(dumpBasePath, GetDumpGenericFileName(DumpStrStat::SPLITTED), genericSplittedDumpData, splitTextPrefix);
|
||||
DumpVectorDataToJson(dumpBasePath, GetDumpGenericFileName(DumpStrStat::FMT), genericFmtTextDumpData);
|
||||
genericTextDumpData.clear();
|
||||
genericSplittedDumpData.clear();
|
||||
genericOrigTextDumpData.clear();
|
||||
genericFmtTextDumpData.clear();
|
||||
inDumpGeneric = false;
|
||||
}).detach();
|
||||
}
|
||||
|
||||
bool GetGenericText(const std::string& origText, std::string* newStr) {
|
||||
// 完全匹配
|
||||
if (const auto iter = genericText.find(origText); iter != genericText.end()) {
|
||||
*newStr = iter->second;
|
||||
return true;
|
||||
}
|
||||
// 不翻译翻译过的文本
|
||||
if (translatedText.contains(origText)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// 匹配升级卡名
|
||||
if (auto plusPos = origText.find_last_not_of('+'); plusPos != std::string::npos) {
|
||||
const auto noPlusText = origText.substr(0, plusPos + 1);
|
||||
|
||||
if (const auto iter = genericText.find(noPlusText); iter != genericText.end()) {
|
||||
size_t plusCount = origText.length() - (plusPos + 1);
|
||||
*newStr = iter->second + std::string(plusCount, '+');
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// fmt 文本
|
||||
auto fmtText = StringParser::ParseItems::parse(origText, false);
|
||||
if (fmtText.isValid) {
|
||||
const auto fmtStr = fmtText.ToFmtString();
|
||||
if (auto it = genericFmtText.find(fmtStr); it != genericFmtText.end()) {
|
||||
auto newRet = fmtText.MergeText(it->second);
|
||||
if (!newRet.empty()) {
|
||||
*newStr = newRet;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
if (Config::dumpText) {
|
||||
DumpGenericText(fmtStr, DumpStrStat::FMT);
|
||||
}
|
||||
}
|
||||
|
||||
auto ret = false;
|
||||
|
||||
// 分割匹配
|
||||
std::vector<std::string> unTransResultRet;
|
||||
const auto splitTransStat = GetSplitTagsTranslationFull(origText, newStr, unTransResultRet);
|
||||
switch (splitTransStat) {
|
||||
case SplitTagsTranslationStat::FULL_TRANS: {
|
||||
DumpGenericText(origText, DumpStrStat::SPLITTABLE_ORIG);
|
||||
return true;
|
||||
} break;
|
||||
|
||||
case SplitTagsTranslationStat::NO_SPLIT_AND_EMPTY: {
|
||||
return false;
|
||||
} break;
|
||||
|
||||
case SplitTagsTranslationStat::NO_SPLIT: {
|
||||
ret = false;
|
||||
} break;
|
||||
|
||||
case SplitTagsTranslationStat::NO_TRANS: {
|
||||
ret = false;
|
||||
} break;
|
||||
|
||||
case SplitTagsTranslationStat::PART_TRANS: {
|
||||
ret = true;
|
||||
} break;
|
||||
}
|
||||
|
||||
if (!Config::dumpText) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
if (unTransResultRet.empty() || (splitTransStat == SplitTagsTranslationStat::NO_SPLIT)) {
|
||||
DumpGenericText(origText);
|
||||
}
|
||||
else {
|
||||
for (const auto& i : unTransResultRet) {
|
||||
DumpGenericText(i, DumpStrStat::SPLITTED);
|
||||
}
|
||||
// 若未翻译部分长度为1，且未翻译文本等于原文本，则不 dump 到原文本文件
|
||||
//if (unTransResultRet.size() != 1 || unTransResultRet[0] != origText) {
|
||||
DumpGenericText(origText, DumpStrStat::SPLITTABLE_ORIG);
|
||||
//}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
std::string ChangeDumpTextIndex(int changeValue) {
|
||||
if (!Config::dumpText) return "";
|
||||
genericDumpFileIndex += changeValue;
|
||||
return Log::StringFormat("GenericDumpFile: %s", GetDumpGenericFileName().c_str());
|
||||
}
|
||||
|
||||
std::string OnKeyDown(int message, int key) {
|
||||
if (message == WM_KEYDOWN) {
|
||||
switch (key) {
|
||||
case KEY_ADD: {
|
||||
return ChangeDumpTextIndex(1);
|
||||
} break;
|
||||
case KEY_SUB: {
|
||||
return ChangeDumpTextIndex(-1);
|
||||
} break;
|
||||
}
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
#ifndef GAKUMAS_LOCALIFY_LOCAL_H
|
||||
#define GAKUMAS_LOCALIFY_LOCAL_H
|
||||
|
||||
#include <string>
|
||||
#include <filesystem>
|
||||
#include <unordered_set>
|
||||
|
||||
namespace GakumasLocal::Local {
|
||||
extern std::unordered_set<std::string> translatedText;
|
||||
|
||||
std::filesystem::path GetBasePath();
|
||||
void LoadData();
|
||||
bool GetI18n(const std::string& key, std::string* ret);
|
||||
void DumpI18nItem(const std::string& key, const std::string& value);
|
||||
|
||||
bool GetResourceText(const std::string& name, std::string* ret);
|
||||
bool GetGenericText(const std::string& origText, std::string* newStr);
|
||||
|
||||
std::string OnKeyDown(int message, int key);
|
||||
}
|
||||
|
||||
#endif //GAKUMAS_LOCALIFY_LOCAL_H
|
||||
|
|
@ -0,0 +1,160 @@
|
|||
#include "Log.h"
|
||||
#include "Misc.hpp"
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <thread>
|
||||
#include <queue>
|
||||
#include <cstdarg>
|
||||
|
||||
#ifdef GKMS_ANDROID
|
||||
#include <android/log.h>
|
||||
|
||||
extern JavaVM* g_javaVM;
|
||||
extern jclass g_gakumasHookMainClass;
|
||||
extern jmethodID showToastMethodId;
|
||||
#elif defined(GKMS_IOS)
|
||||
extern "C" void GKMSShowToastIOS(const char* text);
|
||||
#endif // GKMS_WINDOWS
|
||||
|
||||
|
||||
#define GetParamStringResult(name)\
|
||||
va_list args;\
|
||||
va_start(args, fmt);\
|
||||
va_list args_copy;\
|
||||
va_copy(args_copy, args);\
|
||||
int size = vsnprintf(nullptr, 0, fmt, args_copy) + 1;\
|
||||
va_end(args_copy);\
|
||||
char* buffer = new char[size];\
|
||||
vsnprintf(buffer, size, fmt, args);\
|
||||
va_end(args);\
|
||||
std::string name(buffer);\
|
||||
delete[] buffer
|
||||
|
||||
|
||||
namespace GakumasLocal::Log {
|
||||
namespace {
|
||||
std::queue<std::string> showingToasts{};
|
||||
}
|
||||
|
||||
std::string StringFormat(const char* fmt, ...) {
|
||||
GetParamStringResult(result);
|
||||
return result;
|
||||
}
|
||||
|
||||
void Log(int prio, const char* msg) {
|
||||
__android_log_write(prio, "GakumasLocal-Native", msg);
|
||||
}
|
||||
|
||||
void LogFmt(int prio, const char* fmt, ...) {
|
||||
GetParamStringResult(result);
|
||||
Log(prio, result.c_str());
|
||||
}
|
||||
|
||||
void Info(const char* msg) {
|
||||
Log(ANDROID_LOG_INFO, msg);
|
||||
}
|
||||
|
||||
void InfoFmt(const char* fmt, ...) {
|
||||
GetParamStringResult(result);
|
||||
Info(result.c_str());
|
||||
}
|
||||
|
||||
void Error(const char* msg) {
|
||||
Log(ANDROID_LOG_ERROR, msg);
|
||||
}
|
||||
|
||||
void ErrorFmt(const char* fmt, ...) {
|
||||
GetParamStringResult(result);
|
||||
Error(result.c_str());
|
||||
}
|
||||
|
||||
void Debug(const char* msg) {
|
||||
Log(ANDROID_LOG_DEBUG, msg);
|
||||
}
|
||||
|
||||
void DebugFmt(const char* fmt, ...) {
|
||||
GetParamStringResult(result);
|
||||
Debug(result.c_str());
|
||||
}
|
||||
|
||||
void LogUnityLog(int prio, const char* fmt, ...) {
|
||||
GetParamStringResult(result);
|
||||
__android_log_write(prio, "GakumasLog", result.c_str());
|
||||
}
|
||||
|
||||
/*
|
||||
void ShowToastJNI(const char* text) {
|
||||
DebugFmt("Toast: %s", text);
|
||||
|
||||
std::thread([text](){
|
||||
auto env = Misc::GetJNIEnv();
|
||||
if (!env) {
|
||||
return;
|
||||
}
|
||||
|
||||
jclass& kotlinClass = g_gakumasHookMainClass;
|
||||
if (!kotlinClass) {
|
||||
g_javaVM->DetachCurrentThread();
|
||||
return;
|
||||
}
|
||||
jmethodID& methodId = showToastMethodId;
|
||||
if (!methodId) {
|
||||
g_javaVM->DetachCurrentThread();
|
||||
return;
|
||||
}
|
||||
jstring param = env->NewStringUTF(text);
|
||||
env->CallStaticVoidMethod(kotlinClass, methodId, param);
|
||||
|
||||
g_javaVM->DetachCurrentThread();
|
||||
}).detach();
|
||||
}*/
|
||||
|
||||
|
||||
void ShowToast(const std::string& text) {
|
||||
#ifdef GKMS_ANDROID
|
||||
showingToasts.push(text);
|
||||
#elif defined(GKMS_IOS)
|
||||
GKMSShowToastIOS(text.c_str());
|
||||
#else
|
||||
InfoFmt("Toast: %s", text.c_str());
|
||||
#endif
|
||||
}
|
||||
|
||||
void ShowToast(const char* text) {
|
||||
// DebugFmt("Toast: %s", text);
|
||||
return ShowToast(std::string(text));
|
||||
}
|
||||
|
||||
void ShowToastFmt(const char* fmt, ...) {
|
||||
GetParamStringResult(result);
|
||||
ShowToast(result);
|
||||
}
|
||||
|
||||
std::string GetQueuedToast() {
|
||||
if (showingToasts.empty()) {
|
||||
return "";
|
||||
}
|
||||
const auto ret = showingToasts.front();
|
||||
showingToasts.pop();
|
||||
return ret;
|
||||
}
|
||||
|
||||
#ifdef GKMS_ANDROID
|
||||
void ToastLoop(JNIEnv *env, jclass clazz) {
|
||||
const auto toastString = GetQueuedToast();
|
||||
if (toastString.empty()) return;
|
||||
|
||||
static auto _showToastMethodId = env->GetStaticMethodID(clazz, "showToast", "(Ljava/lang/String;)V");
|
||||
|
||||
if (env && clazz && _showToastMethodId) {
|
||||
jstring param = env->NewStringUTF(toastString.c_str());
|
||||
env->CallStaticVoidMethod(clazz, _showToastMethodId, param);
|
||||
env->DeleteLocalRef(param);
|
||||
}
|
||||
else {
|
||||
_showToastMethodId = env->GetStaticMethodID(clazz, "showToast", "(Ljava/lang/String;)V");
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
#pragma once
|
||||
|
||||
#include "../../src/platformDefine.hpp"
|
||||
|
||||
#include <string>
|
||||
|
||||
#ifdef GKMS_ANDROID
|
||||
#include <jni.h>
|
||||
#endif
|
||||
|
||||
|
||||
namespace GakumasLocal::Log {
|
||||
std::string StringFormat(const char* fmt, ...);
|
||||
void LogUnityLog(int prio, const char* fmt, ...);
|
||||
void LogFmt(int prio, const char* fmt, ...);
|
||||
void Info(const char* msg);
|
||||
void InfoFmt(const char* fmt, ...);
|
||||
void Error(const char* msg);
|
||||
void ErrorFmt(const char* fmt, ...);
|
||||
void Debug(const char* msg);
|
||||
void DebugFmt(const char* fmt, ...);
|
||||
|
||||
void ShowToast(const char* text);
|
||||
void ShowToastFmt(const char* fmt, ...);
|
||||
|
||||
#ifdef GKMS_ANDROID
|
||||
void ToastLoop(JNIEnv *env, jclass clazz);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,815 @@
|
|||
#include "MasterLocal.h"
|
||||
#include "Local.h"
|
||||
#include "Il2cppUtils.hpp"
|
||||
#include "config/Config.hpp"
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
#include <unordered_map>
|
||||
#include <unordered_set>
|
||||
#include <vector>
|
||||
#include <regex>
|
||||
#include <nlohmann/json.hpp>
|
||||
|
||||
#include "../il2cpp_dump/il2cppTypes.hpp"
|
||||
|
||||
namespace GakumasLocal::MasterLocal {
|
||||
using Il2cppString = Il2cppTypes::String;
|
||||
|
||||
static std::unordered_map<std::string, Il2cppUtils::MethodInfo*> fieldSetCache;
|
||||
static std::unordered_map<std::string, Il2cppUtils::MethodInfo*> fieldGetCache;
|
||||
|
||||
enum class JsonValueType {
|
||||
JVT_String,
|
||||
JVT_Int,
|
||||
JVT_Object,
|
||||
JVT_ArrayObject,
|
||||
JVT_ArrayString,
|
||||
JVT_Unsupported,
|
||||
JVT_NeedMore_EmptyArray
|
||||
};
|
||||
|
||||
struct ItemRule {
|
||||
std::vector<std::string> mainPrimaryKey;
|
||||
std::map<std::string, std::vector<std::string>> subPrimaryKey;
|
||||
|
||||
std::vector<std::string> mainLocalKey;
|
||||
std::map<std::string, std::vector<std::string>> subLocalKey;
|
||||
};
|
||||
|
||||
struct TableLocalData {
|
||||
ItemRule itemRule;
|
||||
|
||||
std::unordered_map<std::string, JsonValueType> mainKeyType;
|
||||
std::unordered_map<std::string, std::unordered_map<std::string, JsonValueType>> subKeyType;
|
||||
|
||||
std::unordered_map<std::string, std::string> transData;
|
||||
std::unordered_map<std::string, std::vector<std::string>> transStrListData;
|
||||
|
||||
[[nodiscard]] JsonValueType GetMainKeyType(const std::string& mainKey) const {
|
||||
if (auto it = mainKeyType.find(mainKey); it != mainKeyType.end()) {
|
||||
return it->second;
|
||||
}
|
||||
return JsonValueType::JVT_Unsupported;
|
||||
}
|
||||
|
||||
[[nodiscard]] JsonValueType GetSubKeyType(const std::string& parentKey, const std::string& subKey) const {
|
||||
if (auto it = subKeyType.find(parentKey); it != subKeyType.end()) {
|
||||
if (auto subIt = it->second.find(subKey); subIt != it->second.end()) {
|
||||
return subIt->second;
|
||||
}
|
||||
}
|
||||
return JsonValueType::JVT_Unsupported;
|
||||
}
|
||||
};
|
||||
|
||||
static std::unordered_map<std::string, TableLocalData> masterLocalData;
|
||||
|
||||
class FieldController {
|
||||
void* self;
|
||||
std::string self_klass_name;
|
||||
|
||||
static std::string capitalizeFirstLetter(const std::string& input) {
|
||||
if (input.empty()) return input;
|
||||
std::string result = input;
|
||||
result[0] = static_cast<char>(std::toupper(result[0]));
|
||||
return result;
|
||||
}
|
||||
|
||||
Il2cppUtils::MethodInfo* GetGetSetMethodFromCache(const std::string& fieldName, int argsCount,
|
||||
std::unordered_map<std::string, Il2cppUtils::MethodInfo*>& fromCache, const std::string& prefix = "set_") {
|
||||
const std::string methodName = prefix + capitalizeFirstLetter(fieldName);
|
||||
const std::string searchName = self_klass_name + "." + methodName;
|
||||
|
||||
if (auto it = fromCache.find(searchName); it != fromCache.end()) {
|
||||
return it->second;
|
||||
}
|
||||
auto set_mtd = Il2cppUtils::il2cpp_class_get_method_from_name(
|
||||
self_klass,
|
||||
methodName.c_str(),
|
||||
argsCount
|
||||
);
|
||||
fromCache.emplace(searchName, set_mtd);
|
||||
return set_mtd;
|
||||
}
|
||||
|
||||
public:
|
||||
Il2cppUtils::Il2CppClassHead* self_klass;
|
||||
|
||||
explicit FieldController(void* from) {
|
||||
if (!from) {
|
||||
self = nullptr;
|
||||
return;
|
||||
}
|
||||
self = from;
|
||||
self_klass = Il2cppUtils::get_class_from_instance(self);
|
||||
if (self_klass) {
|
||||
self_klass_name = self_klass->name;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T ReadField(const std::string& fieldName) {
|
||||
if (!self) return T();
|
||||
auto get_mtd = GetGetSetMethodFromCache(fieldName, 0, fieldGetCache, "get_");
|
||||
if (get_mtd) {
|
||||
auto ret = reinterpret_cast<T (*)(void*, void*)>(get_mtd->methodPointer)(self, get_mtd);
|
||||
return ret;
|
||||
}
|
||||
auto field = Il2cppJson::InvokeIl2cpp<Il2cppUtils::FieldInfo*>(
|
||||
"il2cpp_class_get_field_from_name",
|
||||
self_klass,
|
||||
(fieldName + '_').c_str()
|
||||
);
|
||||
if (!field) {
|
||||
return T();
|
||||
}
|
||||
return Il2cppUtils::ClassGetFieldValue<T>(self, field);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void SetField(const std::string& fieldName, T value) {
|
||||
if (!self) return;
|
||||
auto set_mtd = GetGetSetMethodFromCache(fieldName, 1, fieldSetCache, "set_");
|
||||
if (set_mtd) {
|
||||
reinterpret_cast<void (*)(void*, T, void*)>(
|
||||
set_mtd->methodPointer
|
||||
)(self, value, set_mtd);
|
||||
return;
|
||||
}
|
||||
auto field = Il2cppJson::InvokeIl2cpp<Il2cppUtils::FieldInfo*>(
|
||||
"il2cpp_class_get_field_from_name",
|
||||
self_klass,
|
||||
(fieldName + '_').c_str()
|
||||
);
|
||||
if (!field) return;
|
||||
Il2cppUtils::ClassSetFieldValue(self, field, value);
|
||||
}
|
||||
|
||||
int ReadIntField(const std::string& fieldName) {
|
||||
return ReadField<int>(fieldName);
|
||||
}
|
||||
|
||||
Il2cppString* ReadStringField(const std::string& fieldName) {
|
||||
if (!self) return nullptr;
|
||||
auto get_mtd = GetGetSetMethodFromCache(fieldName, 0, fieldGetCache, "get_");
|
||||
if (!get_mtd) {
|
||||
return ReadField<Il2cppString*>(fieldName);
|
||||
}
|
||||
|
||||
auto returnClass = Il2cppJson::InvokeIl2cpp<Il2cppUtils::Il2CppClassHead*>(
|
||||
"il2cpp_class_from_type",
|
||||
// UnityResolve::Invoke<void*>("il2cpp_method_get_return_type", get_mtd)
|
||||
// Il2cppUtils::il2cpp_method_get_return_type(get_mtd)
|
||||
get_mtd->return_type
|
||||
);
|
||||
if (!returnClass) {
|
||||
return reinterpret_cast<Il2cppString* (*)(void*, void*)>(
|
||||
get_mtd->methodPointer
|
||||
)(self, get_mtd);
|
||||
}
|
||||
// auto isEnum = UnityResolve::Invoke<bool>("il2cpp_class_is_enum", returnClass);
|
||||
auto isEnum = Il2cppUtils::il2cpp_class_is_enum(reinterpret_cast<int64_t>(static_cast<void*>(returnClass)));
|
||||
if (!isEnum) {
|
||||
return reinterpret_cast<Il2cppString* (*)(void*, void*)>(
|
||||
get_mtd->methodPointer
|
||||
)(self, get_mtd);
|
||||
}
|
||||
auto enumMap = Il2cppUtils::EnumToValueMap(returnClass, true);
|
||||
auto enumValue = reinterpret_cast<int (*)(void*, void*)>(
|
||||
get_mtd->methodPointer
|
||||
)(self, get_mtd);
|
||||
if (auto it = enumMap.find(enumValue); it != enumMap.end()) {
|
||||
return Il2cppString::New(it->second);
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void SetStringField(const std::string& fieldName, const std::string& value) {
|
||||
if (!self) return;
|
||||
auto newString = Il2cppString::New(value);
|
||||
SetField(fieldName, newString);
|
||||
}
|
||||
|
||||
void SetStringListField(const std::string& fieldName, const std::vector<std::string>& data) {
|
||||
if (!self) return;
|
||||
static auto List_String_klass = Il2cppUtils::get_system_class_from_reflection_type_str(
|
||||
"System.Collections.Generic.List`1[System.String]"
|
||||
);
|
||||
static auto List_String_ctor_mtd = Il2cppUtils::il2cpp_class_get_method_from_name(
|
||||
List_String_klass, ".ctor", 0
|
||||
);
|
||||
static auto List_String_ctor = reinterpret_cast<void (*)(void*, void*)>(
|
||||
List_String_ctor_mtd->methodPointer
|
||||
);
|
||||
|
||||
auto newList = Il2cppJson::InvokeIl2cpp<void*>("il2cpp_object_new", List_String_klass);
|
||||
List_String_ctor(newList, List_String_ctor_mtd);
|
||||
|
||||
Il2cppUtils::Tools::CSListEditor<Il2cppString*> newListEditor(newList);
|
||||
for (auto& s : data) {
|
||||
newListEditor.Add(Il2cppString::New(s));
|
||||
}
|
||||
SetField(fieldName, newList);
|
||||
}
|
||||
|
||||
void* ReadObjectField(const std::string& fieldName) {
|
||||
if (!self) return nullptr;
|
||||
return ReadField<void*>(fieldName);
|
||||
}
|
||||
|
||||
void* ReadObjectListField(const std::string& fieldName) {
|
||||
if (!self) return nullptr;
|
||||
return ReadField<void*>(fieldName);
|
||||
}
|
||||
|
||||
static FieldController CreateSubFieldController(void* subObj) {
|
||||
return FieldController(subObj);
|
||||
}
|
||||
|
||||
FieldController CreateSubFieldController(const std::string& subObjName) {
|
||||
auto field = ReadObjectField(subObjName);
|
||||
return FieldController(field);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
JsonValueType checkJsonValueType(const nlohmann::json& j) {
|
||||
if (j.is_string()) return JsonValueType::JVT_String;
|
||||
if (j.is_number_integer()) return JsonValueType::JVT_Int;
|
||||
if (j.is_object()) return JsonValueType::JVT_Object;
|
||||
if (j.is_array()) {
|
||||
if (!j.empty()) {
|
||||
if (j.begin()->is_object()) {
|
||||
return JsonValueType::JVT_ArrayObject;
|
||||
}
|
||||
else if (j.begin()->is_string()) {
|
||||
return JsonValueType::JVT_ArrayString;
|
||||
}
|
||||
}
|
||||
else {
|
||||
return JsonValueType::JVT_NeedMore_EmptyArray;
|
||||
}
|
||||
}
|
||||
return JsonValueType::JVT_Unsupported;
|
||||
}
|
||||
|
||||
|
||||
std::string ReadFileToString(const std::filesystem::path& path) {
|
||||
std::ifstream ifs(path, std::ios::binary);
|
||||
if (!ifs) return {};
|
||||
std::stringstream buffer;
|
||||
buffer << ifs.rdbuf();
|
||||
return buffer.str();
|
||||
}
|
||||
|
||||
namespace Load {
|
||||
std::vector<std::string> ArrayStrJsonToVec(nlohmann::json& data) {
|
||||
return data;
|
||||
}
|
||||
|
||||
bool BuildObjectItemLocalRule(nlohmann::json& transData, ItemRule& itemRule) {
|
||||
// transData: data[]
|
||||
bool hasSuccess = false;
|
||||
for (auto& data : transData) {
|
||||
// data: {"id": "xxx", "produceDescriptions": [{"k", "v"}], "descriptions": {"k2", "v2"}}
|
||||
if (!data.is_object()) continue;
|
||||
for (auto& [key, value] : data.items()) {
|
||||
// key: "id", value: "xxx"
|
||||
// key: "produceDescriptions", value: [{"k", "v"}]
|
||||
const auto valueType = checkJsonValueType(value);
|
||||
switch (valueType) {
|
||||
case JsonValueType::JVT_String:
|
||||
// case JsonValueType::JVT_Int:
|
||||
case JsonValueType::JVT_ArrayString: {
|
||||
if (std::find(itemRule.mainPrimaryKey.begin(), itemRule.mainPrimaryKey.end(), key) != itemRule.mainPrimaryKey.end()) {
|
||||
continue;
|
||||
}
|
||||
if (auto it = std::find(itemRule.mainLocalKey.begin(), itemRule.mainLocalKey.end(), key); it == itemRule.mainLocalKey.end()) {
|
||||
itemRule.mainLocalKey.emplace_back(key);
|
||||
}
|
||||
hasSuccess = true;
|
||||
} break;
|
||||
|
||||
case JsonValueType::JVT_Object: {
|
||||
ItemRule currRule{ .mainPrimaryKey = itemRule.subPrimaryKey[key] };
|
||||
|
||||
auto vJson = nlohmann::json::array();
|
||||
vJson.push_back(value);
|
||||
|
||||
if (BuildObjectItemLocalRule(vJson, currRule)) {
|
||||
itemRule.subLocalKey.emplace(key, currRule.mainLocalKey);
|
||||
hasSuccess = true;
|
||||
}
|
||||
} break;
|
||||
|
||||
case JsonValueType::JVT_ArrayObject: {
|
||||
for (auto& obj : value) {
|
||||
// obj: {"k", "v"}
|
||||
ItemRule currRule{ .mainPrimaryKey = itemRule.subPrimaryKey[key] };
|
||||
if (BuildObjectItemLocalRule(value, currRule)) {
|
||||
itemRule.subLocalKey.emplace(key, currRule.mainLocalKey);
|
||||
hasSuccess = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
} break;
|
||||
|
||||
case JsonValueType::JVT_Unsupported:
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (hasSuccess) break;
|
||||
}
|
||||
return hasSuccess;
|
||||
}
|
||||
|
||||
bool GetItemRule(nlohmann::json& fullData, ItemRule& itemRule) {
|
||||
auto& primaryKeys = fullData["rules"]["primaryKeys"];
|
||||
auto& transData = fullData["data"];
|
||||
if (!primaryKeys.is_array()) return false;
|
||||
if (!transData.is_array()) return false;
|
||||
|
||||
// 首先构造 mainPrimaryKey 规则
|
||||
for (auto& pkItem : primaryKeys) {
|
||||
if (!pkItem.is_string()) {
|
||||
return false;
|
||||
}
|
||||
std::string pk = pkItem;
|
||||
auto dotCount = std::count(pk.begin(), pk.end(), '.');
|
||||
if (dotCount == 0) {
|
||||
itemRule.mainPrimaryKey.emplace_back(pk);
|
||||
}
|
||||
else if (dotCount == 1) {
|
||||
auto [parentKey, subKey] = Misc::StringFormat::split_once(pk, ".");
|
||||
if (itemRule.subPrimaryKey.contains(parentKey)) {
|
||||
itemRule.subPrimaryKey[parentKey].emplace_back(subKey);
|
||||
}
|
||||
else {
|
||||
itemRule.subPrimaryKey.emplace(parentKey, std::vector<std::string>{subKey});
|
||||
}
|
||||
}
|
||||
else {
|
||||
Log::ErrorFmt("Unsupported depth: %d", dotCount);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
return BuildObjectItemLocalRule(transData, itemRule);
|
||||
}
|
||||
|
||||
std::string BuildBaseMainUniqueKey(nlohmann::json& data, TableLocalData& tableLocalData) {
|
||||
try {
|
||||
std::string mainBaseUniqueKey;
|
||||
for (auto& mainPrimaryKey : tableLocalData.itemRule.mainPrimaryKey) {
|
||||
if (!data.contains(mainPrimaryKey)) {
|
||||
return "";
|
||||
}
|
||||
auto& value = data[mainPrimaryKey];
|
||||
if (value.is_number_integer()) {
|
||||
mainBaseUniqueKey.append(std::to_string(value.get<int>()));
|
||||
}
|
||||
else {
|
||||
mainBaseUniqueKey.append(value);
|
||||
}
|
||||
mainBaseUniqueKey.push_back('|');
|
||||
}
|
||||
return mainBaseUniqueKey;
|
||||
}
|
||||
catch (std::exception& e) {
|
||||
Log::ErrorFmt("LoadData - BuildBaseMainUniqueKey failed: %s", e.what());
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
void BuildBaseObjectSubUniqueKey(nlohmann::json& value, JsonValueType valueType, std::string& currLocalKey) {
|
||||
switch (valueType) {
|
||||
case JsonValueType::JVT_String:
|
||||
currLocalKey.append(value.get<std::string>()); // p_card-00-acc-0_002|0|produceDescriptions|ProduceDescriptionType_Exam|
|
||||
currLocalKey.push_back('|');
|
||||
break;
|
||||
case JsonValueType::JVT_Int:
|
||||
currLocalKey.append(std::to_string(value.get<int>()));
|
||||
currLocalKey.push_back('|');
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
bool BuildUniqueKeyValue(nlohmann::json& data, TableLocalData& tableLocalData) {
|
||||
// 首先处理 main 部分
|
||||
const std::string mainBaseUniqueKey = BuildBaseMainUniqueKey(data, tableLocalData); // p_card-00-acc-0_002|0|
|
||||
if (mainBaseUniqueKey.empty()) return false;
|
||||
for (auto& mainLocalKey : tableLocalData.itemRule.mainLocalKey) {
|
||||
if (!data.contains(mainLocalKey)) continue;
|
||||
auto& currLocalValue = data[mainLocalKey];
|
||||
auto currUniqueKey = mainBaseUniqueKey + mainLocalKey; // p_card-00-acc-0_002|0|name
|
||||
if (tableLocalData.GetMainKeyType(mainLocalKey) == JsonValueType::JVT_ArrayString) {
|
||||
tableLocalData.transStrListData.emplace(currUniqueKey, ArrayStrJsonToVec(currLocalValue));
|
||||
}
|
||||
else {
|
||||
tableLocalData.transData.emplace(currUniqueKey, currLocalValue);
|
||||
}
|
||||
}
|
||||
// 然后处理 sub 部分
|
||||
/*
|
||||
for (const auto& [subPrimaryParentKey, subPrimarySubKeys] : tableLocalData.itemRule.subPrimaryKey) {
|
||||
if (!data.contains(subPrimaryParentKey)) continue;
|
||||
|
||||
const std::string subBaseUniqueKey = mainBaseUniqueKey + subPrimaryParentKey + '|'; // p_card-00-acc-0_002|0|produceDescriptions|
|
||||
|
||||
auto subValueType = checkJsonValueType(data[subPrimaryParentKey]);
|
||||
std::string currLocalKey = subBaseUniqueKey; // p_card-00-acc-0_002|0|produceDescriptions|
|
||||
switch (subValueType) {
|
||||
case JsonValueType::JVT_Object: {
|
||||
for (auto& subPrimarySubKey : subPrimarySubKeys) {
|
||||
if (!data[subPrimaryParentKey].contains(subPrimarySubKey)) continue;
|
||||
auto& value = data[subPrimaryParentKey][subPrimarySubKey];
|
||||
auto valueType = tableLocalData.GetSubKeyType(subPrimaryParentKey, subPrimarySubKey);
|
||||
BuildBaseObjectSubUniqueKey(value, valueType, currLocalKey); // p_card-00-acc-0_002|0|produceDescriptions|ProduceDescriptionType_Exam|
|
||||
}
|
||||
} break;
|
||||
case JsonValueType::JVT_ArrayObject: {
|
||||
int currIndex = 0;
|
||||
for (auto& obj : data[subPrimaryParentKey]) {
|
||||
for (auto& subPrimarySubKey : subPrimarySubKeys) {
|
||||
|
||||
}
|
||||
currIndex++;
|
||||
}
|
||||
} break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}*/
|
||||
|
||||
for (const auto& [subLocalParentKey, subLocalSubKeys] : tableLocalData.itemRule.subLocalKey) {
|
||||
if (!data.contains(subLocalParentKey)) continue;
|
||||
|
||||
const std::string subBaseUniqueKey = mainBaseUniqueKey + subLocalParentKey + '|'; // p_card-00-acc-0_002|0|produceDescriptions|
|
||||
auto subValueType = checkJsonValueType(data[subLocalParentKey]);
|
||||
if (subValueType != JsonValueType::JVT_NeedMore_EmptyArray) {
|
||||
tableLocalData.mainKeyType.emplace(subLocalParentKey, subValueType); // 在这里插入 subParent 的类型
|
||||
}
|
||||
switch (subValueType) {
|
||||
case JsonValueType::JVT_Object: {
|
||||
for (auto& localSubKey : subLocalSubKeys) {
|
||||
const std::string currLocalUniqueKey = subBaseUniqueKey + localSubKey; // p_card-00-acc-0_002|0|produceDescriptions|text
|
||||
if (tableLocalData.GetSubKeyType(subLocalParentKey, localSubKey) == JsonValueType::JVT_ArrayString) {
|
||||
tableLocalData.transStrListData.emplace(currLocalUniqueKey, ArrayStrJsonToVec(data[subLocalParentKey][localSubKey]));
|
||||
}
|
||||
else {
|
||||
tableLocalData.transData.emplace(currLocalUniqueKey, data[subLocalParentKey][localSubKey]);
|
||||
}
|
||||
}
|
||||
} break;
|
||||
case JsonValueType::JVT_ArrayObject: {
|
||||
int currIndex = 0;
|
||||
for (auto& obj : data[subLocalParentKey]) {
|
||||
for (auto& localSubKey : subLocalSubKeys) {
|
||||
std::string currLocalUniqueKey = subBaseUniqueKey; // p_card-00-acc-0_002|0|produceDescriptions|
|
||||
currLocalUniqueKey.push_back('[');
|
||||
currLocalUniqueKey.append(std::to_string(currIndex));
|
||||
currLocalUniqueKey.append("]|");
|
||||
currLocalUniqueKey.append(localSubKey); // p_card-00-acc-0_002|0|produceDescriptions|[0]|text
|
||||
|
||||
if (tableLocalData.GetSubKeyType(subLocalParentKey, localSubKey) == JsonValueType::JVT_ArrayString) {
|
||||
// if (obj[localSubKey].is_array()) {
|
||||
tableLocalData.transStrListData.emplace(currLocalUniqueKey, ArrayStrJsonToVec(obj[localSubKey]));
|
||||
}
|
||||
else if (obj[localSubKey].is_string()) {
|
||||
tableLocalData.transData.emplace(currLocalUniqueKey, obj[localSubKey]);
|
||||
}
|
||||
}
|
||||
currIndex++;
|
||||
}
|
||||
} break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
#define MainKeyTypeProcess() if (!data.contains(mainPrimaryKey)) { Log::ErrorFmt("mainPrimaryKey: %s not found", mainPrimaryKey.c_str()); isFailed = true; break; } \
|
||||
auto currType = checkJsonValueType(data[mainPrimaryKey]); \
|
||||
if (currType == JsonValueType::JVT_NeedMore_EmptyArray) goto NextLoop; \
|
||||
tableLocalData.mainKeyType[mainPrimaryKey] = currType
|
||||
#define SubKeyTypeProcess() if (!data.contains(subKeyParent)) { Log::ErrorFmt("subKeyParent: %s not found", subKeyParent.c_str()); isFailed = true; break; } \
|
||||
for (auto& subKey : subKeys) { \
|
||||
auto& subKeyValue = data[subKeyParent]; \
|
||||
if (subKeyValue.is_object()) { \
|
||||
if (!subKeyValue.contains(subKey)) { \
|
||||
Log::ErrorFmt("subKey: %s not in subKeyParent: %s", subKey.c_str(), subKeyParent.c_str()); isFailed = true; break; \
|
||||
} \
|
||||
auto currType = checkJsonValueType(subKeyValue[subKey]); \
|
||||
if (currType == JsonValueType::JVT_NeedMore_EmptyArray) goto NextLoop; \
|
||||
tableLocalData.subKeyType[subKeyParent].emplace(subKey, currType); \
|
||||
} \
|
||||
else if (subKeyValue.is_array()) { \
|
||||
if (subKeyValue.empty()) goto NextLoop; \
|
||||
for (auto& i : subKeyValue) { \
|
||||
if (!i.is_object()) continue; \
|
||||
if (!i.contains(subKey)) continue; \
|
||||
auto currType = checkJsonValueType(i[subKey]); \
|
||||
if (currType == JsonValueType::JVT_NeedMore_EmptyArray) goto NextLoop; \
|
||||
tableLocalData.subKeyType[subKeyParent].emplace(subKey, currType); \
|
||||
break; \
|
||||
} \
|
||||
} \
|
||||
else { \
|
||||
goto NextLoop;\
|
||||
} \
|
||||
}
|
||||
|
||||
bool GetTableLocalData(nlohmann::json& fullData, TableLocalData& tableLocalData) {
|
||||
bool isFailed = false;
|
||||
|
||||
// 首先 Build mainKeyType 和 subKeyType
|
||||
for (auto& data : fullData["data"]) {
|
||||
if (!data.is_object()) continue;
|
||||
|
||||
for (auto& mainPrimaryKey : tableLocalData.itemRule.mainPrimaryKey) {
|
||||
MainKeyTypeProcess();
|
||||
}
|
||||
for (auto& mainPrimaryKey : tableLocalData.itemRule.mainLocalKey) {
|
||||
MainKeyTypeProcess();
|
||||
}
|
||||
|
||||
for (const auto& [subKeyParent, subKeys] : tableLocalData.itemRule.subPrimaryKey) {
|
||||
SubKeyTypeProcess()
|
||||
|
||||
if (isFailed) break;
|
||||
}
|
||||
for (const auto& [subKeyParent, subKeys] : tableLocalData.itemRule.subLocalKey) {
|
||||
SubKeyTypeProcess()
|
||||
if (isFailed) break;
|
||||
}
|
||||
if (!isFailed) break;
|
||||
NextLoop:
|
||||
;
|
||||
}
|
||||
|
||||
if (isFailed) return false;
|
||||
|
||||
bool hasSuccess = false;
|
||||
// 然后构造 transData
|
||||
for (auto& data : fullData["data"]) {
|
||||
if (!data.is_object()) continue;
|
||||
if (BuildUniqueKeyValue(data, tableLocalData)) {
|
||||
hasSuccess = true;
|
||||
}
|
||||
}
|
||||
if (!hasSuccess) {
|
||||
Log::ErrorFmt("BuildUniqueKeyValue failed.");
|
||||
}
|
||||
return hasSuccess;
|
||||
}
|
||||
|
||||
void LoadData() {
|
||||
masterLocalData.clear();
|
||||
static auto masterDir = Local::GetBasePath() / "local-files" / "masterTrans";
|
||||
if (!std::filesystem::is_directory(masterDir)) {
|
||||
Log::ErrorFmt("LoadData: not found: %s", masterDir.string().c_str());
|
||||
return;
|
||||
}
|
||||
|
||||
bool isFirstIteration = true;
|
||||
for (auto& p : std::filesystem::directory_iterator(masterDir)) {
|
||||
if (isFirstIteration) {
|
||||
auto totalFileCount = std::distance(
|
||||
std::filesystem::directory_iterator(masterDir),
|
||||
std::filesystem::directory_iterator{}
|
||||
);
|
||||
// UnityResolveProgress::classProgress.total = totalFileCount <= 0 ? 1 : totalFileCount;
|
||||
isFirstIteration = false;
|
||||
}
|
||||
// UnityResolveProgress::classProgress.current++;
|
||||
|
||||
if (!p.is_regular_file()) continue;
|
||||
const auto& path = p.path();
|
||||
if (path.extension() != ".json") continue;
|
||||
|
||||
std::string tableName = path.stem().string();
|
||||
auto fileContent = ReadFileToString(path);
|
||||
if (fileContent.empty()) continue;
|
||||
|
||||
try {
|
||||
auto j = nlohmann::json::parse(fileContent);
|
||||
if (!j.contains("rules") || !j["rules"].contains("primaryKeys")) {
|
||||
continue;
|
||||
}
|
||||
ItemRule currRule;
|
||||
if (!GetItemRule(j, currRule)) {
|
||||
Log::ErrorFmt("GetItemRule failed: %s", path.string().c_str());
|
||||
continue;
|
||||
}
|
||||
|
||||
/*
|
||||
if (tableName == "ProduceStepEventDetail") {
|
||||
for (auto& i : currRule.mainLocalKey) {
|
||||
Log::DebugFmt("currRule.mainLocalKey: %s", i.c_str());
|
||||
}
|
||||
for (auto& i : currRule.mainPrimaryKey) {
|
||||
Log::DebugFmt("currRule.mainPrimaryKey: %s", i.c_str());
|
||||
}
|
||||
for (auto& i : currRule.subLocalKey) {
|
||||
for (auto& m : i.second) {
|
||||
Log::DebugFmt("currRule.subLocalKey: %s - %s", i.first.c_str(), m.c_str());
|
||||
}
|
||||
}
|
||||
for (auto& i : currRule.subPrimaryKey) {
|
||||
for (auto& m : i.second) {
|
||||
Log::DebugFmt("currRule.subPrimaryKey: %s - %s", i.first.c_str(), m.c_str());
|
||||
}
|
||||
}
|
||||
}*/
|
||||
|
||||
TableLocalData tableLocalData{ .itemRule = currRule };
|
||||
if (GetTableLocalData(j, tableLocalData)) {
|
||||
for (auto& i : tableLocalData.transData) {
|
||||
// Log::DebugFmt("%s: %s -> %s", tableName.c_str(), i.first.c_str(), i.second.c_str());
|
||||
Local::translatedText.emplace(i.second);
|
||||
}
|
||||
for (auto& i : tableLocalData.transStrListData) {
|
||||
for (auto& str : i.second) {
|
||||
// Log::DebugFmt("%s[]: %s -> %s", tableName.c_str(), i.first.c_str(), str.c_str());
|
||||
Local::translatedText.emplace(str);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
if (tableName == "ProduceStepEventDetail") {
|
||||
for (auto& i : tableLocalData.mainKeyType) {
|
||||
Log::DebugFmt("mainKeyType: %s -> %d", i.first.c_str(), i.second);
|
||||
}
|
||||
for (auto& i : tableLocalData.subKeyType) {
|
||||
for (auto& m : i.second) {
|
||||
Log::DebugFmt("subKeyType: %s - %s -> %d", i.first.c_str(), m.first.c_str(), m.second);
|
||||
}
|
||||
}
|
||||
}*/
|
||||
// JVT_ArrayString in HelpCategory, ProduceStory, Tutorial
|
||||
|
||||
masterLocalData.emplace(tableName, std::move(tableLocalData));
|
||||
}
|
||||
else {
|
||||
Log::ErrorFmt("GetTableLocalData failed: %s", path.string().c_str());
|
||||
}
|
||||
} catch (std::exception& e) {
|
||||
Log::ErrorFmt("MasterLocal::LoadData: parse error in '%s': %s",
|
||||
path.string().c_str(), e.what());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void LoadData() {
|
||||
return Load::LoadData();
|
||||
}
|
||||
|
||||
std::string GetTransString(const std::string& key, const TableLocalData& localData) {
|
||||
if (auto it = localData.transData.find(key); it != localData.transData.end()) {
|
||||
return it->second;
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
std::vector<std::string> GetTransArrayString(const std::string& key, const TableLocalData& localData) {
|
||||
if (auto it = localData.transStrListData.find(key); it != localData.transStrListData.end()) {
|
||||
return it->second;
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
void LocalizeMasterItem(FieldController& fc, const std::string& tableName) {
|
||||
auto it = masterLocalData.find(tableName);
|
||||
if (it == masterLocalData.end()) return;
|
||||
const auto& localData = it->second;
|
||||
|
||||
// 首先拼 BasePrimaryKey
|
||||
std::string baseDataKey; // p_card-00-acc-0_002|0|
|
||||
for (auto& mainPk : localData.itemRule.mainPrimaryKey) {
|
||||
auto mainPkType = localData.GetMainKeyType(mainPk);
|
||||
switch (mainPkType) {
|
||||
case JsonValueType::JVT_Int: {
|
||||
auto readValue = std::to_string(fc.ReadIntField(mainPk));
|
||||
baseDataKey.append(readValue);
|
||||
baseDataKey.push_back('|');
|
||||
} break;
|
||||
case JsonValueType::JVT_String: {
|
||||
auto readValue = fc.ReadStringField(mainPk);
|
||||
if (!readValue) return;
|
||||
baseDataKey.append(readValue->ToString());
|
||||
baseDataKey.push_back('|');
|
||||
} break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// 然后本地化 mainLocal
|
||||
for (auto& mainLocal : localData.itemRule.mainLocalKey) {
|
||||
std::string currSearchKey = baseDataKey;
|
||||
currSearchKey.append(mainLocal); // p_card-00-acc-0_002|0|name
|
||||
auto localVType = localData.GetMainKeyType(mainLocal);
|
||||
switch (localVType) {
|
||||
case JsonValueType::JVT_String: {
|
||||
auto localValue = GetTransString(currSearchKey, localData);
|
||||
if (!localValue.empty()) {
|
||||
fc.SetStringField(mainLocal, localValue);
|
||||
}
|
||||
} break;
|
||||
case JsonValueType::JVT_ArrayString: {
|
||||
auto localValue = GetTransArrayString(currSearchKey, localData);
|
||||
if (!localValue.empty()) {
|
||||
fc.SetStringListField(mainLocal, localValue);
|
||||
}
|
||||
} break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// 处理 sub
|
||||
for (const auto& [subParentKey, subLocalKeys] : localData.itemRule.subLocalKey) {
|
||||
const auto subBaseSearchKey = baseDataKey + subParentKey + '|'; // p_card-00-acc-0_002|0|produceDescriptions|
|
||||
|
||||
const auto subParentType = localData.GetMainKeyType(subParentKey);
|
||||
switch (subParentType) {
|
||||
case JsonValueType::JVT_Object: {
|
||||
auto subParentField = fc.CreateSubFieldController(subParentKey);
|
||||
for (const auto& subLocalKey : subLocalKeys) {
|
||||
const auto currSearchKey = subBaseSearchKey + subLocalKey; // p_card-00-acc-0_002|0|produceDescriptions|text
|
||||
auto localKeyType = localData.GetSubKeyType(subParentKey, subLocalKey);
|
||||
if (localKeyType == JsonValueType::JVT_String) {
|
||||
auto setData = GetTransString(currSearchKey, localData);
|
||||
if (!setData.empty()) {
|
||||
subParentField.SetStringField(subLocalKey, setData);
|
||||
}
|
||||
}
|
||||
else if (localKeyType == JsonValueType::JVT_ArrayString) {
|
||||
auto setData = GetTransArrayString(currSearchKey, localData);
|
||||
if (!setData.empty()) {
|
||||
subParentField.SetStringListField(subLocalKey, setData);
|
||||
}
|
||||
}
|
||||
}
|
||||
} break;
|
||||
case JsonValueType::JVT_ArrayObject: {
|
||||
auto subArrField = fc.ReadObjectListField(subParentKey);
|
||||
if (!subArrField) continue;
|
||||
Il2cppUtils::Tools::CSListEditor<void*> subListEdit(subArrField);
|
||||
auto count = subListEdit.get_Count();
|
||||
for (int idx = 0; idx < count; idx++) {
|
||||
auto currItem = subListEdit.get_Item(idx);
|
||||
if (!currItem) continue;
|
||||
auto currFc = FieldController::CreateSubFieldController(currItem);
|
||||
|
||||
std::string currSearchBaseKey = subBaseSearchKey; // p_card-00-acc-0_002|0|produceDescriptions|
|
||||
currSearchBaseKey.push_back('[');
|
||||
currSearchBaseKey.append(std::to_string(idx));
|
||||
currSearchBaseKey.append("]|"); // p_card-00-acc-0_002|0|produceDescriptions|[0]|
|
||||
|
||||
for (const auto& subLocalKey : subLocalKeys) {
|
||||
std::string currSearchKey = currSearchBaseKey + subLocalKey; // p_card-00-acc-0_002|0|produceDescriptions|[0]|text
|
||||
|
||||
auto localKeyType = localData.GetSubKeyType(subParentKey, subLocalKey);
|
||||
|
||||
/*
|
||||
if (tableName == "ProduceStepEventDetail") {
|
||||
Log::DebugFmt("localKeyType: %d currSearchKey: %s", localKeyType, currSearchKey.c_str());
|
||||
}*/
|
||||
|
||||
if (localKeyType == JsonValueType::JVT_String) {
|
||||
auto setData = GetTransString(currSearchKey, localData);
|
||||
if (!setData.empty()) {
|
||||
currFc.SetStringField(subLocalKey, setData);
|
||||
}
|
||||
}
|
||||
else if (localKeyType == JsonValueType::JVT_ArrayString) {
|
||||
auto setData = GetTransArrayString(currSearchKey, localData);
|
||||
if (!setData.empty()) {
|
||||
currFc.SetStringListField(subLocalKey, setData);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void LocalizeMasterItem(void* item, const std::string& tableName) {
|
||||
if (!Config::useMasterTrans) return;
|
||||
// Log::DebugFmt("LocalizeMasterItem: %s", tableName.c_str());
|
||||
FieldController fc(item);
|
||||
LocalizeMasterItem(fc, tableName);
|
||||
}
|
||||
|
||||
} // namespace GakumasLocal::MasterLocal
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
#ifndef GAKUMAS_LOCALIFY_MASTERLOCAL_H
|
||||
#define GAKUMAS_LOCALIFY_MASTERLOCAL_H
|
||||
|
||||
#include <string>
|
||||
|
||||
namespace GakumasLocal::MasterLocal {
|
||||
void LoadData();
|
||||
|
||||
void LocalizeMasterItem(void* item, const std::string& tableName);
|
||||
}
|
||||
|
||||
#endif //GAKUMAS_LOCALIFY_MASTERLOCAL_H
|
||||
|
|
@ -0,0 +1,225 @@
|
|||
#include "Misc.hpp"
|
||||
|
||||
#include <codecvt>
|
||||
#include <locale>
|
||||
#include "fmt/core.h"
|
||||
|
||||
#ifdef GKMS_ANDROID
|
||||
#include <jni.h>
|
||||
|
||||
extern JavaVM* g_javaVM;
|
||||
#elifdef GKMS_WINDOWS
|
||||
#include "cpprest/details/http_helpers.h"
|
||||
#endif
|
||||
|
||||
|
||||
namespace GakumasLocal::Misc {
|
||||
|
||||
#ifdef GKMS_WINDOWS
|
||||
std::string ToUTF8(const std::wstring_view& str) {
|
||||
return utility::conversions::to_utf8string(str.data());
|
||||
}
|
||||
|
||||
std::u16string ToUTF16(const std::string_view& str) {
|
||||
std::string input(str);
|
||||
std::wstring wstr = utility::conversions::utf8_to_utf16(input);
|
||||
return std::u16string(wstr.begin(), wstr.end());
|
||||
}
|
||||
|
||||
std::string ToUTF8(const std::u16string_view& str) {
|
||||
std::u16string u16(str);
|
||||
std::wstring wstr(u16.begin(), u16.end());
|
||||
return utility::conversions::utf16_to_utf8(wstr);
|
||||
}
|
||||
#else
|
||||
std::u16string ToUTF16(const std::string_view& str) {
|
||||
std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> utf16conv;
|
||||
return utf16conv.from_bytes(str.data(), str.data() + str.size());
|
||||
}
|
||||
|
||||
std::string ToUTF8(const std::u16string_view& str) {
|
||||
std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> utf16conv;
|
||||
return utf16conv.to_bytes(str.data(), str.data() + str.size());
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef GKMS_ANDROID
|
||||
JNIEnv* GetJNIEnv() {
|
||||
if (!g_javaVM) return nullptr;
|
||||
JNIEnv* env = nullptr;
|
||||
if (g_javaVM->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
|
||||
int status = g_javaVM->AttachCurrentThread(&env, nullptr);
|
||||
if (status < 0) {
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
return env;
|
||||
}
|
||||
#endif
|
||||
|
||||
CSEnum::CSEnum(const std::string& name, const int value) {
|
||||
this->Add(name, value);
|
||||
}
|
||||
|
||||
CSEnum::CSEnum(const std::vector<std::string>& names, const std::vector<int>& values) {
|
||||
if (names.size() != values.size()) return;
|
||||
this->names = names;
|
||||
this->values = values;
|
||||
}
|
||||
|
||||
int CSEnum::GetIndex() {
|
||||
return currIndex;
|
||||
}
|
||||
|
||||
void CSEnum::SetIndex(int index) {
|
||||
if (index < 0) return;
|
||||
if (index + 1 >= values.size()) return;
|
||||
currIndex = index;
|
||||
}
|
||||
|
||||
int CSEnum::GetTotalLength() {
|
||||
return values.size();
|
||||
}
|
||||
|
||||
void CSEnum::Add(const std::string &name, const int value) {
|
||||
this->names.push_back(name);
|
||||
this->values.push_back(value);
|
||||
}
|
||||
|
||||
std::pair<std::string, int> CSEnum::GetCurrent() {
|
||||
return std::make_pair(names[currIndex], values[currIndex]);
|
||||
}
|
||||
|
||||
std::pair<std::string, int> CSEnum::Last() {
|
||||
const auto maxIndex = this->GetTotalLength() - 1;
|
||||
if (currIndex <= 0) {
|
||||
currIndex = maxIndex;
|
||||
}
|
||||
else {
|
||||
currIndex--;
|
||||
}
|
||||
return this->GetCurrent();
|
||||
}
|
||||
|
||||
std::pair<std::string, int> CSEnum::Next() {
|
||||
const auto maxIndex = this->GetTotalLength() - 1;
|
||||
if (currIndex >= maxIndex) {
|
||||
currIndex = 0;
|
||||
}
|
||||
else {
|
||||
currIndex++;
|
||||
}
|
||||
return this->GetCurrent();
|
||||
}
|
||||
|
||||
int CSEnum::GetValueByName(const std::string &name) {
|
||||
for (int i = 0; i < names.size(); i++) {
|
||||
if (names[i] == name) {
|
||||
return values[i];
|
||||
}
|
||||
}
|
||||
return values[0];
|
||||
}
|
||||
|
||||
|
||||
namespace StringFormat {
|
||||
template<typename... Args>
|
||||
std::string string_format(const std::string& fmt, Args&&... args) {
|
||||
// return std::vformat(fmt, std::make_format_args(std::forward<Args>(args)...));
|
||||
return fmt::format(fmt::runtime(fmt), std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
|
||||
template <std::size_t N, std::size_t... Indices, typename T>
|
||||
auto vectorToTupleImpl(const std::vector<T>& vec, std::index_sequence<Indices...>) {
|
||||
if (vec.size() != N) {
|
||||
// printf("vec.size: %zu, N: %zu\n", vec.size(), N);
|
||||
throw std::out_of_range("Vector size does not match tuple size.");
|
||||
}
|
||||
return std::make_tuple(vec[Indices]...);
|
||||
}
|
||||
|
||||
template <std::size_t N, typename T>
|
||||
auto vectorToTuple(const std::vector<T>& vec) {
|
||||
return vectorToTupleImpl<N>(vec, std::make_index_sequence<N>{});
|
||||
}
|
||||
|
||||
|
||||
template <typename T>
|
||||
std::string stringFormat(const std::string& fmt, const std::vector<T>& vec) {
|
||||
std::string ret = fmt;
|
||||
|
||||
#define CASE_ARG_COUNT(N) \
|
||||
case N: {\
|
||||
auto tp = vectorToTuple<N>(vec); \
|
||||
std::apply([&](auto&&... args) { \
|
||||
ret = string_format(fmt, args...); \
|
||||
}, tp); } break;
|
||||
|
||||
switch (vec.size()) {
|
||||
CASE_ARG_COUNT(1)
|
||||
CASE_ARG_COUNT(2)
|
||||
CASE_ARG_COUNT(3)
|
||||
CASE_ARG_COUNT(4)
|
||||
CASE_ARG_COUNT(5)
|
||||
CASE_ARG_COUNT(6)
|
||||
CASE_ARG_COUNT(7)
|
||||
CASE_ARG_COUNT(8)
|
||||
CASE_ARG_COUNT(9)
|
||||
CASE_ARG_COUNT(10)
|
||||
CASE_ARG_COUNT(11)
|
||||
CASE_ARG_COUNT(12)
|
||||
CASE_ARG_COUNT(13)
|
||||
CASE_ARG_COUNT(14)
|
||||
CASE_ARG_COUNT(15)
|
||||
CASE_ARG_COUNT(16)
|
||||
CASE_ARG_COUNT(17)
|
||||
CASE_ARG_COUNT(18)
|
||||
CASE_ARG_COUNT(19)
|
||||
CASE_ARG_COUNT(20)
|
||||
CASE_ARG_COUNT(21)
|
||||
CASE_ARG_COUNT(22)
|
||||
CASE_ARG_COUNT(23)
|
||||
CASE_ARG_COUNT(24)
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
std::string stringFormatString(const std::string& fmt, const std::vector<std::string>& vec) {
|
||||
try {
|
||||
return stringFormat(fmt, vec);
|
||||
}
|
||||
catch (std::exception& e) {
|
||||
return fmt;
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<std::string> split(const std::string& str, char delimiter) {
|
||||
std::vector<std::string> result;
|
||||
std::string current;
|
||||
for (char c : str) {
|
||||
if (c == delimiter) {
|
||||
if (!current.empty()) {
|
||||
result.push_back(current);
|
||||
}
|
||||
current.clear();
|
||||
} else {
|
||||
current += c;
|
||||
}
|
||||
}
|
||||
if (!current.empty()) {
|
||||
result.push_back(current);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
std::pair<std::string, std::string> split_once(const std::string& str, const std::string& delimiter) {
|
||||
size_t pos = str.find(delimiter);
|
||||
if (pos != std::string::npos) {
|
||||
return {str.substr(0, pos), str.substr(pos + delimiter.size())};
|
||||
}
|
||||
return {str, ""};
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,94 @@
|
|||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <string_view>
|
||||
#include <deque>
|
||||
#include <numeric>
|
||||
#include <vector>
|
||||
|
||||
#include "../../src/platformDefine.hpp"
|
||||
|
||||
#ifdef GKMS_ANDROID
|
||||
#include <jni.h>
|
||||
#endif
|
||||
|
||||
|
||||
namespace GakumasLocal {
|
||||
using OpaqueFunctionPointer = void (*)();
|
||||
|
||||
namespace Misc {
|
||||
std::u16string ToUTF16(const std::string_view& str);
|
||||
std::string ToUTF8(const std::u16string_view& str);
|
||||
#ifdef GKMS_WINDOWS
|
||||
std::string ToUTF8(const std::wstring_view& str);
|
||||
#endif
|
||||
|
||||
#ifdef GKMS_ANDROID
|
||||
JNIEnv* GetJNIEnv();
|
||||
#endif
|
||||
|
||||
class CSEnum {
|
||||
public:
|
||||
CSEnum(const std::string& name, const int value);
|
||||
|
||||
CSEnum(const std::vector<std::string>& names, const std::vector<int>& values);
|
||||
|
||||
int GetIndex();
|
||||
|
||||
void SetIndex(int index);
|
||||
|
||||
int GetTotalLength();
|
||||
|
||||
void Add(const std::string& name, const int value);
|
||||
|
||||
std::pair<std::string, int> GetCurrent();
|
||||
|
||||
std::pair<std::string, int> Last();
|
||||
|
||||
std::pair<std::string, int> Next();
|
||||
|
||||
int GetValueByName(const std::string& name);
|
||||
|
||||
private:
|
||||
int currIndex = 0;
|
||||
std::vector<std::string> names{};
|
||||
std::vector<int> values{};
|
||||
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
class FixedSizeQueue {
|
||||
static_assert(std::is_arithmetic<T>::value, "T must be an arithmetic type");
|
||||
|
||||
public:
|
||||
FixedSizeQueue(size_t maxSize) : maxSize(maxSize), sum(0) {}
|
||||
|
||||
void Push(T value) {
|
||||
if (deque.size() >= maxSize) {
|
||||
sum -= deque.front();
|
||||
deque.pop_front();
|
||||
}
|
||||
deque.push_back(value);
|
||||
sum += value;
|
||||
}
|
||||
|
||||
float Average() {
|
||||
if (deque.empty()) {
|
||||
return 0.0;
|
||||
}
|
||||
return static_cast<float>(sum) / deque.size();
|
||||
}
|
||||
|
||||
private:
|
||||
std::deque<T> deque;
|
||||
size_t maxSize;
|
||||
T sum;
|
||||
};
|
||||
|
||||
namespace StringFormat {
|
||||
std::string stringFormatString(const std::string& fmt, const std::vector<std::string>& vec);
|
||||
std::vector<std::string> split(const std::string& str, char delimiter);
|
||||
std::pair<std::string, std::string> split_once(const std::string& str, const std::string& delimiter);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
#include "Plugin.h"
|
||||
#include "Hook.h"
|
||||
|
||||
namespace GakumasLocal {
|
||||
HookInstaller::~HookInstaller() {
|
||||
}
|
||||
|
||||
Plugin &Plugin::GetInstance() {
|
||||
static Plugin instance;
|
||||
return instance;
|
||||
}
|
||||
|
||||
void Plugin::SetHookInstaller(std::unique_ptr<HookInstaller>&& hookInstaller)
|
||||
{
|
||||
m_HookInstaller = std::move(hookInstaller);
|
||||
}
|
||||
|
||||
void Plugin::InstallHook(/*std::unique_ptr<HookInstaller>&& hookInstaller*/)
|
||||
{
|
||||
// m_HookInstaller = std::move(hookInstaller);
|
||||
Hook::Install();
|
||||
}
|
||||
|
||||
HookInstaller* Plugin::GetHookInstaller() const
|
||||
{
|
||||
return m_HookInstaller.get();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
#ifndef GAKUMAS_LOCALIFY_PLUGIN_H
|
||||
#define GAKUMAS_LOCALIFY_PLUGIN_H
|
||||
|
||||
#include "Misc.hpp"
|
||||
#include <string>
|
||||
#include <memory>
|
||||
|
||||
#include "../../src/platformDefine.hpp"
|
||||
|
||||
#ifdef GKMS_ANDROID
|
||||
#include <jni.h>
|
||||
#endif // !GKMS_WINDOWS
|
||||
|
||||
|
||||
namespace GakumasLocal {
|
||||
struct HookInstaller
|
||||
{
|
||||
virtual ~HookInstaller();
|
||||
virtual void* InstallHook(void* addr, void* hook, void** orig) = 0;
|
||||
virtual OpaqueFunctionPointer LookupSymbol(const char* name) = 0;
|
||||
|
||||
std::string m_il2cppLibraryPath;
|
||||
std::string localizationFilesDir;
|
||||
};
|
||||
|
||||
class Plugin
|
||||
{
|
||||
public:
|
||||
static Plugin& GetInstance();
|
||||
|
||||
void SetHookInstaller(std::unique_ptr<HookInstaller>&& hookInstaller);
|
||||
|
||||
static void InstallHook(/*std::unique_ptr<HookInstaller>&& hookInstaller*/);
|
||||
|
||||
HookInstaller* GetHookInstaller() const;
|
||||
|
||||
Plugin(Plugin const&) = delete;
|
||||
Plugin& operator=(Plugin const&) = delete;
|
||||
|
||||
private:
|
||||
Plugin() = default;
|
||||
|
||||
std::unique_ptr<HookInstaller> m_HookInstaller;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif //GAKUMAS_LOCALIFY_PLUGIN_H
|
||||
|
|
@ -0,0 +1,177 @@
|
|||
#include <string>
|
||||
#include "nlohmann/json.hpp"
|
||||
#include "../Log.h"
|
||||
#include <thread>
|
||||
#include <fstream>
|
||||
|
||||
namespace GakumasLocal::Config {
|
||||
bool isConfigInit = false;
|
||||
|
||||
bool dbgMode = false;
|
||||
bool enabled = true;
|
||||
bool lazyInit = true;
|
||||
bool replaceFont = true;
|
||||
bool forceExportResource = true;
|
||||
bool textTest = false;
|
||||
bool useMasterTrans = true;
|
||||
int gameOrientation = 0;
|
||||
bool dumpText = false;
|
||||
bool enableFreeCamera = false;
|
||||
int targetFrameRate = 0;
|
||||
bool unlockAllLive = false;
|
||||
bool unlockAllLiveCostume = false;
|
||||
|
||||
bool enableLiveCustomeDress = false;
|
||||
std::string liveCustomeHeadId = "";
|
||||
std::string liveCustomeCostumeId = "";
|
||||
|
||||
bool loginAsIOS = false;
|
||||
|
||||
bool useCustomeGraphicSettings = false;
|
||||
float renderScale = 0.77f;
|
||||
int qualitySettingsLevel = 3;
|
||||
int volumeIndex = 3;
|
||||
int maxBufferPixel = 3384;
|
||||
int reflectionQualityLevel = 4;
|
||||
int lodQualityLevel = 4;
|
||||
|
||||
bool enableBreastParam = false;
|
||||
float bDamping = 0.33f;
|
||||
float bStiffness = 0.08f;
|
||||
float bSpring = 1.0f;
|
||||
float bPendulum = 0.055f;
|
||||
float bPendulumRange = 0.15f;
|
||||
float bAverage = 0.20f;
|
||||
float bRootWeight = 0.5f;
|
||||
bool bUseArmCorrection = true;
|
||||
bool bUseScale = false;
|
||||
float bScale = 1.0f;
|
||||
bool bUseLimit = true;
|
||||
float bLimitXx = 1.0f;
|
||||
float bLimitXy = 1.0f;
|
||||
float bLimitYx = 1.0f;
|
||||
float bLimitYy = 1.0f;
|
||||
float bLimitZx = 1.0f;
|
||||
float bLimitZy = 1.0f;
|
||||
|
||||
bool dmmUnlockSize = false;
|
||||
|
||||
void LoadConfig(const std::string& configStr) {
|
||||
try {
|
||||
const auto config = nlohmann::json::parse(configStr);
|
||||
|
||||
#define GetConfigItem(name) if (config.contains(#name)) name = config[#name]
|
||||
|
||||
GetConfigItem(dbgMode);
|
||||
GetConfigItem(enabled);
|
||||
GetConfigItem(lazyInit);
|
||||
GetConfigItem(replaceFont);
|
||||
GetConfigItem(forceExportResource);
|
||||
GetConfigItem(gameOrientation);
|
||||
GetConfigItem(textTest);
|
||||
GetConfigItem(useMasterTrans);
|
||||
GetConfigItem(dumpText);
|
||||
GetConfigItem(targetFrameRate);
|
||||
GetConfigItem(enableFreeCamera);
|
||||
GetConfigItem(unlockAllLive);
|
||||
GetConfigItem(unlockAllLiveCostume);
|
||||
GetConfigItem(enableLiveCustomeDress);
|
||||
GetConfigItem(liveCustomeHeadId);
|
||||
GetConfigItem(liveCustomeCostumeId);
|
||||
GetConfigItem(loginAsIOS);
|
||||
GetConfigItem(useCustomeGraphicSettings);
|
||||
GetConfigItem(renderScale);
|
||||
GetConfigItem(qualitySettingsLevel);
|
||||
GetConfigItem(volumeIndex);
|
||||
GetConfigItem(maxBufferPixel);
|
||||
GetConfigItem(reflectionQualityLevel);
|
||||
GetConfigItem(lodQualityLevel);
|
||||
GetConfigItem(enableBreastParam);
|
||||
GetConfigItem(bDamping);
|
||||
GetConfigItem(bStiffness);
|
||||
GetConfigItem(bSpring);
|
||||
GetConfigItem(bPendulum);
|
||||
GetConfigItem(bPendulumRange);
|
||||
GetConfigItem(bAverage);
|
||||
GetConfigItem(bRootWeight);
|
||||
GetConfigItem(bUseArmCorrection);
|
||||
GetConfigItem(bUseScale);
|
||||
GetConfigItem(bScale);
|
||||
GetConfigItem(bUseLimit);
|
||||
GetConfigItem(bLimitXx);
|
||||
GetConfigItem(bLimitXy);
|
||||
GetConfigItem(bLimitYx);
|
||||
GetConfigItem(bLimitYy);
|
||||
GetConfigItem(bLimitZx);
|
||||
GetConfigItem(bLimitZy);
|
||||
GetConfigItem(dmmUnlockSize);
|
||||
}
|
||||
catch (std::exception& e) {
|
||||
Log::ErrorFmt("LoadConfig error: %s", e.what());
|
||||
}
|
||||
isConfigInit = true;
|
||||
}
|
||||
|
||||
void SaveConfig(const std::string& configPath) {
|
||||
try {
|
||||
nlohmann::json config;
|
||||
|
||||
#define SetConfigItem(name) config[#name] = name
|
||||
|
||||
SetConfigItem(dbgMode);
|
||||
SetConfigItem(enabled);
|
||||
SetConfigItem(lazyInit);
|
||||
SetConfigItem(replaceFont);
|
||||
SetConfigItem(forceExportResource);
|
||||
SetConfigItem(gameOrientation);
|
||||
SetConfigItem(textTest);
|
||||
SetConfigItem(useMasterTrans);
|
||||
SetConfigItem(dumpText);
|
||||
SetConfigItem(targetFrameRate);
|
||||
SetConfigItem(enableFreeCamera);
|
||||
SetConfigItem(unlockAllLive);
|
||||
SetConfigItem(unlockAllLiveCostume);
|
||||
SetConfigItem(enableLiveCustomeDress);
|
||||
SetConfigItem(liveCustomeHeadId);
|
||||
SetConfigItem(liveCustomeCostumeId);
|
||||
SetConfigItem(loginAsIOS);
|
||||
SetConfigItem(useCustomeGraphicSettings);
|
||||
SetConfigItem(renderScale);
|
||||
SetConfigItem(qualitySettingsLevel);
|
||||
SetConfigItem(volumeIndex);
|
||||
SetConfigItem(maxBufferPixel);
|
||||
SetConfigItem(reflectionQualityLevel);
|
||||
SetConfigItem(lodQualityLevel);
|
||||
SetConfigItem(enableBreastParam);
|
||||
SetConfigItem(bDamping);
|
||||
SetConfigItem(bStiffness);
|
||||
SetConfigItem(bSpring);
|
||||
SetConfigItem(bPendulum);
|
||||
SetConfigItem(bPendulumRange);
|
||||
SetConfigItem(bAverage);
|
||||
SetConfigItem(bRootWeight);
|
||||
SetConfigItem(bUseArmCorrection);
|
||||
SetConfigItem(bUseScale);
|
||||
SetConfigItem(bScale);
|
||||
SetConfigItem(bUseLimit);
|
||||
SetConfigItem(bLimitXx);
|
||||
SetConfigItem(bLimitXy);
|
||||
SetConfigItem(bLimitYx);
|
||||
SetConfigItem(bLimitYy);
|
||||
SetConfigItem(bLimitZx);
|
||||
SetConfigItem(bLimitZy);
|
||||
SetConfigItem(dmmUnlockSize);
|
||||
|
||||
std::ofstream out(configPath);
|
||||
if (!out) {
|
||||
Log::ErrorFmt("SaveConfig error: Cannot open file: %s", configPath.c_str());
|
||||
return;
|
||||
}
|
||||
out << config.dump(4);
|
||||
Log::Info("SaveConfig success");
|
||||
}
|
||||
catch (std::exception& e) {
|
||||
Log::ErrorFmt("SaveConfig error: %s", e.what());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
#pragma once
|
||||
|
||||
namespace GakumasLocal::Config {
|
||||
extern bool isConfigInit;
|
||||
|
||||
extern bool dbgMode;
|
||||
extern bool enabled;
|
||||
extern bool lazyInit;
|
||||
extern bool replaceFont;
|
||||
extern bool forceExportResource;
|
||||
extern int gameOrientation;
|
||||
extern bool textTest;
|
||||
extern bool useMasterTrans;
|
||||
extern bool dumpText;
|
||||
extern bool enableFreeCamera;
|
||||
extern int targetFrameRate;
|
||||
extern bool unlockAllLive;
|
||||
extern bool unlockAllLiveCostume;
|
||||
|
||||
extern bool enableLiveCustomeDress;
|
||||
extern std::string liveCustomeHeadId;
|
||||
extern std::string liveCustomeCostumeId;
|
||||
|
||||
extern bool loginAsIOS;
|
||||
|
||||
extern bool useCustomeGraphicSettings;
|
||||
extern float renderScale;
|
||||
extern int qualitySettingsLevel;
|
||||
extern int volumeIndex;
|
||||
extern int maxBufferPixel;
|
||||
|
||||
extern int reflectionQualityLevel;
|
||||
extern int lodQualityLevel;
|
||||
|
||||
extern bool enableBreastParam;
|
||||
extern float bDamping;
|
||||
extern float bStiffness;
|
||||
extern float bSpring;
|
||||
extern float bPendulum;
|
||||
extern float bPendulumRange;
|
||||
extern float bAverage;
|
||||
extern float bRootWeight;
|
||||
extern bool bUseArmCorrection;
|
||||
extern bool bUseScale;
|
||||
extern float bScale;
|
||||
extern bool bUseLimit;
|
||||
extern float bLimitXx;
|
||||
extern float bLimitXy;
|
||||
extern float bLimitYx;
|
||||
extern float bLimitYy;
|
||||
extern float bLimitZx;
|
||||
extern float bLimitZy;
|
||||
|
||||
extern bool dmmUnlockSize;
|
||||
|
||||
void LoadConfig(const std::string& configStr);
|
||||
void SaveConfig(const std::string& configPath);
|
||||
}
|
||||
|
|
@ -0,0 +1,123 @@
|
|||
#include <unordered_set>
|
||||
#include "StringParser.hpp"
|
||||
#include "fmt/core.h"
|
||||
#include "fmt/ranges.h"
|
||||
#include "../Misc.hpp"
|
||||
|
||||
namespace StringParser {
|
||||
|
||||
std::string ParseItems::ToFmtString() {
|
||||
std::vector<std::string> ret{};
|
||||
int currFlagIndex = 0;
|
||||
for (const auto& i : items) {
|
||||
if (i.type == ParseItemType::FLAG) {
|
||||
ret.push_back(fmt::format("{{{}}}", currFlagIndex));
|
||||
currFlagIndex++;
|
||||
}
|
||||
else {
|
||||
ret.push_back(i.content);
|
||||
}
|
||||
}
|
||||
return fmt::format("{}", fmt::join(ret, ""));
|
||||
}
|
||||
|
||||
std::vector<std::string> ParseItems::GetFlagValues() {
|
||||
std::vector<std::string> ret{};
|
||||
for (const auto& i : items) {
|
||||
if (i.type == ParseItemType::FLAG) {
|
||||
ret.push_back(i.content);
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
ParseItems ParseItems::parse(const std::string &str, bool parseTags) {
|
||||
static const std::unordered_set<char16_t> splitFlags = {u'0', u'1', u'2', u'3', u'4', u'5',
|
||||
u'6', u'7', u'8', u'9', u'+', u'＋',
|
||||
u'-', u'－', u'%', u'％',
|
||||
u'.', u'×', u',', u'，'};
|
||||
|
||||
ParseItems result;
|
||||
if (str.find("{") != std::string::npos) {
|
||||
result.isValid = false;
|
||||
return result;
|
||||
}
|
||||
std::u16string origText = GakumasLocal::Misc::ToUTF16(str);
|
||||
bool isInTag = false;
|
||||
bool isInFlagSequence = false;
|
||||
std::u16string currentCacheText;
|
||||
|
||||
for (char16_t currChar : origText) {
|
||||
if (parseTags && currChar == u'<') {
|
||||
if (!currentCacheText.empty()) {
|
||||
result.items.push_back({isInFlagSequence ? ParseItemType::FLAG : ParseItemType::TEXT,
|
||||
GakumasLocal::Misc::ToUTF8(currentCacheText)});
|
||||
currentCacheText.clear();
|
||||
isInFlagSequence = false;
|
||||
}
|
||||
isInTag = true;
|
||||
currentCacheText.push_back(currChar);
|
||||
} else if (parseTags && currChar == u'>') {
|
||||
isInTag = false;
|
||||
currentCacheText.push_back(currChar);
|
||||
result.items.push_back({ParseItemType::FLAG, GakumasLocal::Misc::ToUTF8(currentCacheText)});
|
||||
currentCacheText.clear();
|
||||
} else if (isInTag) {
|
||||
currentCacheText.push_back(currChar);
|
||||
} else if (splitFlags.contains(currChar)) {
|
||||
if (!isInFlagSequence && !currentCacheText.empty()) {
|
||||
result.items.push_back({ParseItemType::TEXT, GakumasLocal::Misc::ToUTF8(currentCacheText)});
|
||||
currentCacheText.clear();
|
||||
}
|
||||
isInFlagSequence = true;
|
||||
currentCacheText.push_back(currChar);
|
||||
} else {
|
||||
if (isInFlagSequence && !currentCacheText.empty()) {
|
||||
result.items.push_back({ParseItemType::FLAG, GakumasLocal::Misc::ToUTF8(currentCacheText)});
|
||||
currentCacheText.clear();
|
||||
isInFlagSequence = false;
|
||||
}
|
||||
currentCacheText.push_back(currChar);
|
||||
}
|
||||
}
|
||||
|
||||
if (!currentCacheText.empty()) {
|
||||
result.items.push_back({isInFlagSequence ? ParseItemType::FLAG : ParseItemType::TEXT,
|
||||
GakumasLocal::Misc::ToUTF8(currentCacheText)});
|
||||
}
|
||||
|
||||
for (auto& i : result.items) {
|
||||
if (i.type == ParseItemType::FLAG) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
result.isValid = false;
|
||||
return result;
|
||||
}
|
||||
|
||||
std::string ParseItems::MergeText(ParseItems &textTarget, ParseItems &valueTarget) {
|
||||
if (!textTarget.isValid) return "";
|
||||
if (!valueTarget.isValid) return "";
|
||||
const auto fmtText = textTarget.ToFmtString();
|
||||
const auto values = valueTarget.GetFlagValues();
|
||||
const std::string ret = GakumasLocal::Misc::StringFormat::stringFormatString(fmtText, values);
|
||||
return {ret.begin(), ret.end()};
|
||||
}
|
||||
|
||||
std::string ParseItems::MergeText(const std::string &newStr) {
|
||||
if (!isValid) return "";
|
||||
const auto values = GetFlagValues();
|
||||
return GakumasLocal::Misc::StringFormat::stringFormatString(newStr, values);
|
||||
}
|
||||
|
||||
int ParseItems::GetFlagCount() {
|
||||
int ret = 0;
|
||||
for (auto& i : items) {
|
||||
if (i.type == ParseItemType::FLAG) {
|
||||
ret++;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace StringParser {
|
||||
enum class ParseItemType {
|
||||
FLAG,
|
||||
TEXT
|
||||
};
|
||||
|
||||
struct ParseItem {
|
||||
ParseItemType type;
|
||||
std::string content;
|
||||
};
|
||||
|
||||
struct ParseItems {
|
||||
bool isValid = true;
|
||||
std::vector<ParseItem> items;
|
||||
|
||||
std::string ToFmtString();
|
||||
std::vector<std::string> GetFlagValues();
|
||||
std::string MergeText(const std::string& newStr);
|
||||
int GetFlagCount();
|
||||
|
||||
static ParseItems parse(const std::string& str, bool parseTags);
|
||||
static std::string MergeText(ParseItems& textTarget, ParseItems& valueTarget);
|
||||
};
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,67 @@
|
|||
//
|
||||
// Created by RanKaeder on 2024/6/18.
|
||||
//
|
||||
|
||||
#ifndef GAKUMAS_LOCALIFY_JOYSTICKEVENT_H
|
||||
#define GAKUMAS_LOCALIFY_JOYSTICKEVENT_H
|
||||
|
||||
class JoystickEvent {
|
||||
public:
|
||||
JoystickEvent(int message, float leftStickX, float leftStickY, float rightStickX,
|
||||
float rightStickY, float leftTrigger, float rightTrigger,
|
||||
float hatX, float hatY)
|
||||
: message(message), leftStickX(leftStickX), leftStickY(leftStickY),
|
||||
rightStickX(rightStickX), rightStickY(rightStickY), leftTrigger(leftTrigger),
|
||||
rightTrigger(rightTrigger), hatX(hatX), hatY(hatY) {
|
||||
}
|
||||
|
||||
// Getter 方法
|
||||
int getMessage() const {
|
||||
return message;
|
||||
}
|
||||
|
||||
float getLeftStickX() const {
|
||||
return leftStickX;
|
||||
}
|
||||
|
||||
float getLeftStickY() const {
|
||||
return leftStickY;
|
||||
}
|
||||
|
||||
float getRightStickX() const {
|
||||
return rightStickX;
|
||||
}
|
||||
|
||||
float getRightStickY() const {
|
||||
return rightStickY;
|
||||
}
|
||||
|
||||
float getLeftTrigger() const {
|
||||
return leftTrigger;
|
||||
}
|
||||
|
||||
float getRightTrigger() const {
|
||||
return rightTrigger;
|
||||
}
|
||||
|
||||
float getHatX() const {
|
||||
return hatX;
|
||||
}
|
||||
|
||||
float getHatY() const {
|
||||
return hatY;
|
||||
}
|
||||
|
||||
private:
|
||||
int message;
|
||||
float leftStickX;
|
||||
float leftStickY;
|
||||
float rightStickX;
|
||||
float rightStickY;
|
||||
float leftTrigger;
|
||||
float rightTrigger;
|
||||
float hatX;
|
||||
float hatY;
|
||||
};
|
||||
|
||||
#endif //GAKUMAS_LOCALIFY_JOYSTICKEVENT_H
|
||||
|
|
@ -0,0 +1,228 @@
|
|||
// Formatting library for C++ - dynamic argument lists
|
||||
//
|
||||
// Copyright (c) 2012 - present, Victor Zverovich
|
||||
// All rights reserved.
|
||||
//
|
||||
// For the license information refer to format.h.
|
||||
|
||||
#ifndef FMT_ARGS_H_
|
||||
#define FMT_ARGS_H_
|
||||
|
||||
#ifndef FMT_MODULE
|
||||
# include <functional> // std::reference_wrapper
|
||||
# include <memory> // std::unique_ptr
|
||||
# include <vector>
|
||||
#endif
|
||||
|
||||
#include "format.h" // std_string_view
|
||||
|
||||
FMT_BEGIN_NAMESPACE
|
||||
|
||||
namespace detail {
|
||||
|
||||
template <typename T> struct is_reference_wrapper : std::false_type {};
|
||||
template <typename T>
|
||||
struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
|
||||
|
||||
template <typename T> auto unwrap(const T& v) -> const T& { return v; }
|
||||
template <typename T>
|
||||
auto unwrap(const std::reference_wrapper<T>& v) -> const T& {
|
||||
return static_cast<const T&>(v);
|
||||
}
|
||||
|
||||
// node is defined outside dynamic_arg_list to workaround a C2504 bug in MSVC
|
||||
// 2022 (v17.10.0).
|
||||
//
|
||||
// Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
|
||||
// templates it doesn't complain about inability to deduce single translation
|
||||
// unit for placing vtable. So node is made a fake template.
|
||||
template <typename = void> struct node {
|
||||
virtual ~node() = default;
|
||||
std::unique_ptr<node<>> next;
|
||||
};
|
||||
|
||||
class dynamic_arg_list {
|
||||
template <typename T> struct typed_node : node<> {
|
||||
T value;
|
||||
|
||||
template <typename Arg>
|
||||
FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {}
|
||||
|
||||
template <typename Char>
|
||||
FMT_CONSTEXPR typed_node(const basic_string_view<Char>& arg)
|
||||
: value(arg.data(), arg.size()) {}
|
||||
};
|
||||
|
||||
std::unique_ptr<node<>> head_;
|
||||
|
||||
public:
|
||||
template <typename T, typename Arg> auto push(const Arg& arg) -> const T& {
|
||||
auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
|
||||
auto& value = new_node->value;
|
||||
new_node->next = std::move(head_);
|
||||
head_ = std::move(new_node);
|
||||
return value;
|
||||
}
|
||||
};
|
||||
} // namespace detail
|
||||
|
||||
/**
|
||||
* A dynamic list of formatting arguments with storage.
|
||||
*
|
||||
* It can be implicitly converted into `fmt::basic_format_args` for passing
|
||||
* into type-erased formatting functions such as `fmt::vformat`.
|
||||
*/
|
||||
template <typename Context>
|
||||
class dynamic_format_arg_store
|
||||
#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
|
||||
// Workaround a GCC template argument substitution bug.
|
||||
: public basic_format_args<Context>
|
||||
#endif
|
||||
{
|
||||
private:
|
||||
using char_type = typename Context::char_type;
|
||||
|
||||
template <typename T> struct need_copy {
|
||||
static constexpr detail::type mapped_type =
|
||||
detail::mapped_type_constant<T, Context>::value;
|
||||
|
||||
enum {
|
||||
value = !(detail::is_reference_wrapper<T>::value ||
|
||||
std::is_same<T, basic_string_view<char_type>>::value ||
|
||||
std::is_same<T, detail::std_string_view<char_type>>::value ||
|
||||
(mapped_type != detail::type::cstring_type &&
|
||||
mapped_type != detail::type::string_type &&
|
||||
mapped_type != detail::type::custom_type))
|
||||
};
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
using stored_type = conditional_t<
|
||||
std::is_convertible<T, std::basic_string<char_type>>::value &&
|
||||
!detail::is_reference_wrapper<T>::value,
|
||||
std::basic_string<char_type>, T>;
|
||||
|
||||
// Storage of basic_format_arg must be contiguous.
|
||||
std::vector<basic_format_arg<Context>> data_;
|
||||
std::vector<detail::named_arg_info<char_type>> named_info_;
|
||||
|
||||
// Storage of arguments not fitting into basic_format_arg must grow
|
||||
// without relocation because items in data_ refer to it.
|
||||
detail::dynamic_arg_list dynamic_args_;
|
||||
|
||||
friend class basic_format_args<Context>;
|
||||
|
||||
auto get_types() const -> unsigned long long {
|
||||
return detail::is_unpacked_bit | data_.size() |
|
||||
(named_info_.empty()
|
||||
? 0ULL
|
||||
: static_cast<unsigned long long>(detail::has_named_args_bit));
|
||||
}
|
||||
|
||||
auto data() const -> const basic_format_arg<Context>* {
|
||||
return named_info_.empty() ? data_.data() : data_.data() + 1;
|
||||
}
|
||||
|
||||
template <typename T> void emplace_arg(const T& arg) {
|
||||
data_.emplace_back(detail::make_arg<Context>(arg));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void emplace_arg(const detail::named_arg<char_type, T>& arg) {
|
||||
if (named_info_.empty()) {
|
||||
constexpr const detail::named_arg_info<char_type>* zero_ptr{nullptr};
|
||||
data_.insert(data_.begin(), {zero_ptr, 0});
|
||||
}
|
||||
data_.emplace_back(detail::make_arg<Context>(detail::unwrap(arg.value)));
|
||||
auto pop_one = [](std::vector<basic_format_arg<Context>>* data) {
|
||||
data->pop_back();
|
||||
};
|
||||
std::unique_ptr<std::vector<basic_format_arg<Context>>, decltype(pop_one)>
|
||||
guard{&data_, pop_one};
|
||||
named_info_.push_back({arg.name, static_cast<int>(data_.size() - 2u)});
|
||||
data_[0].value_.named_args = {named_info_.data(), named_info_.size()};
|
||||
guard.release();
|
||||
}
|
||||
|
||||
public:
|
||||
constexpr dynamic_format_arg_store() = default;
|
||||
|
||||
/**
|
||||
* Adds an argument into the dynamic store for later passing to a formatting
|
||||
* function.
|
||||
*
|
||||
* Note that custom types and string types (but not string views) are copied
|
||||
* into the store dynamically allocating memory if necessary.
|
||||
*
|
||||
* **Example**:
|
||||
*
|
||||
* fmt::dynamic_format_arg_store<fmt::format_context> store;
|
||||
* store.push_back(42);
|
||||
* store.push_back("abc");
|
||||
* store.push_back(1.5f);
|
||||
* std::string result = fmt::vformat("{} and {} and {}", store);
|
||||
*/
|
||||
template <typename T> void push_back(const T& arg) {
|
||||
if (detail::const_check(need_copy<T>::value))
|
||||
emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
|
||||
else
|
||||
emplace_arg(detail::unwrap(arg));
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds a reference to the argument into the dynamic store for later passing
|
||||
* to a formatting function.
|
||||
*
|
||||
* **Example**:
|
||||
*
|
||||
* fmt::dynamic_format_arg_store<fmt::format_context> store;
|
||||
* char band[] = "Rolling Stones";
|
||||
* store.push_back(std::cref(band));
|
||||
* band[9] = 'c'; // Changing str affects the output.
|
||||
* std::string result = fmt::vformat("{}", store);
|
||||
* // result == "Rolling Scones"
|
||||
*/
|
||||
template <typename T> void push_back(std::reference_wrapper<T> arg) {
|
||||
static_assert(
|
||||
need_copy<T>::value,
|
||||
"objects of built-in types and string views are always copied");
|
||||
emplace_arg(arg.get());
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds named argument into the dynamic store for later passing to a
|
||||
* formatting function. `std::reference_wrapper` is supported to avoid
|
||||
* copying of the argument. The name is always copied into the store.
|
||||
*/
|
||||
template <typename T>
|
||||
void push_back(const detail::named_arg<char_type, T>& arg) {
|
||||
const char_type* arg_name =
|
||||
dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str();
|
||||
if (detail::const_check(need_copy<T>::value)) {
|
||||
emplace_arg(
|
||||
fmt::arg(arg_name, dynamic_args_.push<stored_type<T>>(arg.value)));
|
||||
} else {
|
||||
emplace_arg(fmt::arg(arg_name, arg.value));
|
||||
}
|
||||
}
|
||||
|
||||
/// Erase all elements from the store.
|
||||
void clear() {
|
||||
data_.clear();
|
||||
named_info_.clear();
|
||||
dynamic_args_ = detail::dynamic_arg_list();
|
||||
}
|
||||
|
||||
/// Reserves space to store at least `new_cap` arguments including
|
||||
/// `new_cap_named` named arguments.
|
||||
void reserve(size_t new_cap, size_t new_cap_named) {
|
||||
FMT_ASSERT(new_cap >= new_cap_named,
|
||||
"Set of arguments includes set of named arguments");
|
||||
data_.reserve(new_cap);
|
||||
named_info_.reserve(new_cap_named);
|
||||
}
|
||||
};
|
||||
|
||||
FMT_END_NAMESPACE
|
||||
|
||||
#endif // FMT_ARGS_H_
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,612 @@
|
|||
// Formatting library for C++ - color support
|
||||
//
|
||||
// Copyright (c) 2018 - present, Victor Zverovich and fmt contributors
|
||||
// All rights reserved.
|
||||
//
|
||||
// For the license information refer to format.h.
|
||||
|
||||
#ifndef FMT_COLOR_H_
|
||||
#define FMT_COLOR_H_
|
||||
|
||||
#include "format.h"
|
||||
|
||||
FMT_BEGIN_NAMESPACE
|
||||
FMT_BEGIN_EXPORT
|
||||
|
||||
enum class color : uint32_t {
|
||||
alice_blue = 0xF0F8FF, // rgb(240,248,255)
|
||||
antique_white = 0xFAEBD7, // rgb(250,235,215)
|
||||
aqua = 0x00FFFF, // rgb(0,255,255)
|
||||
aquamarine = 0x7FFFD4, // rgb(127,255,212)
|
||||
azure = 0xF0FFFF, // rgb(240,255,255)
|
||||
beige = 0xF5F5DC, // rgb(245,245,220)
|
||||
bisque = 0xFFE4C4, // rgb(255,228,196)
|
||||
black = 0x000000, // rgb(0,0,0)
|
||||
blanched_almond = 0xFFEBCD, // rgb(255,235,205)
|
||||
blue = 0x0000FF, // rgb(0,0,255)
|
||||
blue_violet = 0x8A2BE2, // rgb(138,43,226)
|
||||
brown = 0xA52A2A, // rgb(165,42,42)
|
||||
burly_wood = 0xDEB887, // rgb(222,184,135)
|
||||
cadet_blue = 0x5F9EA0, // rgb(95,158,160)
|
||||
chartreuse = 0x7FFF00, // rgb(127,255,0)
|
||||
chocolate = 0xD2691E, // rgb(210,105,30)
|
||||
coral = 0xFF7F50, // rgb(255,127,80)
|
||||
cornflower_blue = 0x6495ED, // rgb(100,149,237)
|
||||
cornsilk = 0xFFF8DC, // rgb(255,248,220)
|
||||
crimson = 0xDC143C, // rgb(220,20,60)
|
||||
cyan = 0x00FFFF, // rgb(0,255,255)
|
||||
dark_blue = 0x00008B, // rgb(0,0,139)
|
||||
dark_cyan = 0x008B8B, // rgb(0,139,139)
|
||||
dark_golden_rod = 0xB8860B, // rgb(184,134,11)
|
||||
dark_gray = 0xA9A9A9, // rgb(169,169,169)
|
||||
dark_green = 0x006400, // rgb(0,100,0)
|
||||
dark_khaki = 0xBDB76B, // rgb(189,183,107)
|
||||
dark_magenta = 0x8B008B, // rgb(139,0,139)
|
||||
dark_olive_green = 0x556B2F, // rgb(85,107,47)
|
||||
dark_orange = 0xFF8C00, // rgb(255,140,0)
|
||||
dark_orchid = 0x9932CC, // rgb(153,50,204)
|
||||
dark_red = 0x8B0000, // rgb(139,0,0)
|
||||
dark_salmon = 0xE9967A, // rgb(233,150,122)
|
||||
dark_sea_green = 0x8FBC8F, // rgb(143,188,143)
|
||||
dark_slate_blue = 0x483D8B, // rgb(72,61,139)
|
||||
dark_slate_gray = 0x2F4F4F, // rgb(47,79,79)
|
||||
dark_turquoise = 0x00CED1, // rgb(0,206,209)
|
||||
dark_violet = 0x9400D3, // rgb(148,0,211)
|
||||
deep_pink = 0xFF1493, // rgb(255,20,147)
|
||||
deep_sky_blue = 0x00BFFF, // rgb(0,191,255)
|
||||
dim_gray = 0x696969, // rgb(105,105,105)
|
||||
dodger_blue = 0x1E90FF, // rgb(30,144,255)
|
||||
fire_brick = 0xB22222, // rgb(178,34,34)
|
||||
floral_white = 0xFFFAF0, // rgb(255,250,240)
|
||||
forest_green = 0x228B22, // rgb(34,139,34)
|
||||
fuchsia = 0xFF00FF, // rgb(255,0,255)
|
||||
gainsboro = 0xDCDCDC, // rgb(220,220,220)
|
||||
ghost_white = 0xF8F8FF, // rgb(248,248,255)
|
||||
gold = 0xFFD700, // rgb(255,215,0)
|
||||
golden_rod = 0xDAA520, // rgb(218,165,32)
|
||||
gray = 0x808080, // rgb(128,128,128)
|
||||
green = 0x008000, // rgb(0,128,0)
|
||||
green_yellow = 0xADFF2F, // rgb(173,255,47)
|
||||
honey_dew = 0xF0FFF0, // rgb(240,255,240)
|
||||
hot_pink = 0xFF69B4, // rgb(255,105,180)
|
||||
indian_red = 0xCD5C5C, // rgb(205,92,92)
|
||||
indigo = 0x4B0082, // rgb(75,0,130)
|
||||
ivory = 0xFFFFF0, // rgb(255,255,240)
|
||||
khaki = 0xF0E68C, // rgb(240,230,140)
|
||||
lavender = 0xE6E6FA, // rgb(230,230,250)
|
||||
lavender_blush = 0xFFF0F5, // rgb(255,240,245)
|
||||
lawn_green = 0x7CFC00, // rgb(124,252,0)
|
||||
lemon_chiffon = 0xFFFACD, // rgb(255,250,205)
|
||||
light_blue = 0xADD8E6, // rgb(173,216,230)
|
||||
light_coral = 0xF08080, // rgb(240,128,128)
|
||||
light_cyan = 0xE0FFFF, // rgb(224,255,255)
|
||||
light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210)
|
||||
light_gray = 0xD3D3D3, // rgb(211,211,211)
|
||||
light_green = 0x90EE90, // rgb(144,238,144)
|
||||
light_pink = 0xFFB6C1, // rgb(255,182,193)
|
||||
light_salmon = 0xFFA07A, // rgb(255,160,122)
|
||||
light_sea_green = 0x20B2AA, // rgb(32,178,170)
|
||||
light_sky_blue = 0x87CEFA, // rgb(135,206,250)
|
||||
light_slate_gray = 0x778899, // rgb(119,136,153)
|
||||
light_steel_blue = 0xB0C4DE, // rgb(176,196,222)
|
||||
light_yellow = 0xFFFFE0, // rgb(255,255,224)
|
||||
lime = 0x00FF00, // rgb(0,255,0)
|
||||
lime_green = 0x32CD32, // rgb(50,205,50)
|
||||
linen = 0xFAF0E6, // rgb(250,240,230)
|
||||
magenta = 0xFF00FF, // rgb(255,0,255)
|
||||
maroon = 0x800000, // rgb(128,0,0)
|
||||
medium_aquamarine = 0x66CDAA, // rgb(102,205,170)
|
||||
medium_blue = 0x0000CD, // rgb(0,0,205)
|
||||
medium_orchid = 0xBA55D3, // rgb(186,85,211)
|
||||
medium_purple = 0x9370DB, // rgb(147,112,219)
|
||||
medium_sea_green = 0x3CB371, // rgb(60,179,113)
|
||||
medium_slate_blue = 0x7B68EE, // rgb(123,104,238)
|
||||
medium_spring_green = 0x00FA9A, // rgb(0,250,154)
|
||||
medium_turquoise = 0x48D1CC, // rgb(72,209,204)
|
||||
medium_violet_red = 0xC71585, // rgb(199,21,133)
|
||||
midnight_blue = 0x191970, // rgb(25,25,112)
|
||||
mint_cream = 0xF5FFFA, // rgb(245,255,250)
|
||||
misty_rose = 0xFFE4E1, // rgb(255,228,225)
|
||||
moccasin = 0xFFE4B5, // rgb(255,228,181)
|
||||
navajo_white = 0xFFDEAD, // rgb(255,222,173)
|
||||
navy = 0x000080, // rgb(0,0,128)
|
||||
old_lace = 0xFDF5E6, // rgb(253,245,230)
|
||||
olive = 0x808000, // rgb(128,128,0)
|
||||
olive_drab = 0x6B8E23, // rgb(107,142,35)
|
||||
orange = 0xFFA500, // rgb(255,165,0)
|
||||
orange_red = 0xFF4500, // rgb(255,69,0)
|
||||
orchid = 0xDA70D6, // rgb(218,112,214)
|
||||
pale_golden_rod = 0xEEE8AA, // rgb(238,232,170)
|
||||
pale_green = 0x98FB98, // rgb(152,251,152)
|
||||
pale_turquoise = 0xAFEEEE, // rgb(175,238,238)
|
||||
pale_violet_red = 0xDB7093, // rgb(219,112,147)
|
||||
papaya_whip = 0xFFEFD5, // rgb(255,239,213)
|
||||
peach_puff = 0xFFDAB9, // rgb(255,218,185)
|
||||
peru = 0xCD853F, // rgb(205,133,63)
|
||||
pink = 0xFFC0CB, // rgb(255,192,203)
|
||||
plum = 0xDDA0DD, // rgb(221,160,221)
|
||||
powder_blue = 0xB0E0E6, // rgb(176,224,230)
|
||||
purple = 0x800080, // rgb(128,0,128)
|
||||
rebecca_purple = 0x663399, // rgb(102,51,153)
|
||||
red = 0xFF0000, // rgb(255,0,0)
|
||||
rosy_brown = 0xBC8F8F, // rgb(188,143,143)
|
||||
royal_blue = 0x4169E1, // rgb(65,105,225)
|
||||
saddle_brown = 0x8B4513, // rgb(139,69,19)
|
||||
salmon = 0xFA8072, // rgb(250,128,114)
|
||||
sandy_brown = 0xF4A460, // rgb(244,164,96)
|
||||
sea_green = 0x2E8B57, // rgb(46,139,87)
|
||||
sea_shell = 0xFFF5EE, // rgb(255,245,238)
|
||||
sienna = 0xA0522D, // rgb(160,82,45)
|
||||
silver = 0xC0C0C0, // rgb(192,192,192)
|
||||
sky_blue = 0x87CEEB, // rgb(135,206,235)
|
||||
slate_blue = 0x6A5ACD, // rgb(106,90,205)
|
||||
slate_gray = 0x708090, // rgb(112,128,144)
|
||||
snow = 0xFFFAFA, // rgb(255,250,250)
|
||||
spring_green = 0x00FF7F, // rgb(0,255,127)
|
||||
steel_blue = 0x4682B4, // rgb(70,130,180)
|
||||
tan = 0xD2B48C, // rgb(210,180,140)
|
||||
teal = 0x008080, // rgb(0,128,128)
|
||||
thistle = 0xD8BFD8, // rgb(216,191,216)
|
||||
tomato = 0xFF6347, // rgb(255,99,71)
|
||||
turquoise = 0x40E0D0, // rgb(64,224,208)
|
||||
violet = 0xEE82EE, // rgb(238,130,238)
|
||||
wheat = 0xF5DEB3, // rgb(245,222,179)
|
||||
white = 0xFFFFFF, // rgb(255,255,255)
|
||||
white_smoke = 0xF5F5F5, // rgb(245,245,245)
|
||||
yellow = 0xFFFF00, // rgb(255,255,0)
|
||||
yellow_green = 0x9ACD32 // rgb(154,205,50)
|
||||
}; // enum class color
|
||||
|
||||
enum class terminal_color : uint8_t {
|
||||
black = 30,
|
||||
red,
|
||||
green,
|
||||
yellow,
|
||||
blue,
|
||||
magenta,
|
||||
cyan,
|
||||
white,
|
||||
bright_black = 90,
|
||||
bright_red,
|
||||
bright_green,
|
||||
bright_yellow,
|
||||
bright_blue,
|
||||
bright_magenta,
|
||||
bright_cyan,
|
||||
bright_white
|
||||
};
|
||||
|
||||
enum class emphasis : uint8_t {
|
||||
bold = 1,
|
||||
faint = 1 << 1,
|
||||
italic = 1 << 2,
|
||||
underline = 1 << 3,
|
||||
blink = 1 << 4,
|
||||
reverse = 1 << 5,
|
||||
conceal = 1 << 6,
|
||||
strikethrough = 1 << 7,
|
||||
};
|
||||
|
||||
// rgb is a struct for red, green and blue colors.
|
||||
// Using the name "rgb" makes some editors show the color in a tooltip.
|
||||
struct rgb {
|
||||
FMT_CONSTEXPR rgb() : r(0), g(0), b(0) {}
|
||||
FMT_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {}
|
||||
FMT_CONSTEXPR rgb(uint32_t hex)
|
||||
: r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {}
|
||||
FMT_CONSTEXPR rgb(color hex)
|
||||
: r((uint32_t(hex) >> 16) & 0xFF),
|
||||
g((uint32_t(hex) >> 8) & 0xFF),
|
||||
b(uint32_t(hex) & 0xFF) {}
|
||||
uint8_t r;
|
||||
uint8_t g;
|
||||
uint8_t b;
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
// color is a struct of either a rgb color or a terminal color.
|
||||
struct color_type {
|
||||
FMT_CONSTEXPR color_type() noexcept : is_rgb(), value{} {}
|
||||
FMT_CONSTEXPR color_type(color rgb_color) noexcept : is_rgb(true), value{} {
|
||||
value.rgb_color = static_cast<uint32_t>(rgb_color);
|
||||
}
|
||||
FMT_CONSTEXPR color_type(rgb rgb_color) noexcept : is_rgb(true), value{} {
|
||||
value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) |
|
||||
(static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
|
||||
}
|
||||
FMT_CONSTEXPR color_type(terminal_color term_color) noexcept
|
||||
: is_rgb(), value{} {
|
||||
value.term_color = static_cast<uint8_t>(term_color);
|
||||
}
|
||||
bool is_rgb;
|
||||
union color_union {
|
||||
uint8_t term_color;
|
||||
uint32_t rgb_color;
|
||||
} value;
|
||||
};
|
||||
} // namespace detail
|
||||
|
||||
/// A text style consisting of foreground and background colors and emphasis.
|
||||
class text_style {
|
||||
public:
|
||||
FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept
|
||||
: set_foreground_color(), set_background_color(), ems(em) {}
|
||||
|
||||
FMT_CONSTEXPR auto operator|=(const text_style& rhs) -> text_style& {
|
||||
if (!set_foreground_color) {
|
||||
set_foreground_color = rhs.set_foreground_color;
|
||||
foreground_color = rhs.foreground_color;
|
||||
} else if (rhs.set_foreground_color) {
|
||||
if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
|
||||
report_error("can't OR a terminal color");
|
||||
foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
|
||||
}
|
||||
|
||||
if (!set_background_color) {
|
||||
set_background_color = rhs.set_background_color;
|
||||
background_color = rhs.background_color;
|
||||
} else if (rhs.set_background_color) {
|
||||
if (!background_color.is_rgb || !rhs.background_color.is_rgb)
|
||||
report_error("can't OR a terminal color");
|
||||
background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
|
||||
}
|
||||
|
||||
ems = static_cast<emphasis>(static_cast<uint8_t>(ems) |
|
||||
static_cast<uint8_t>(rhs.ems));
|
||||
return *this;
|
||||
}
|
||||
|
||||
friend FMT_CONSTEXPR auto operator|(text_style lhs, const text_style& rhs)
|
||||
-> text_style {
|
||||
return lhs |= rhs;
|
||||
}
|
||||
|
||||
FMT_CONSTEXPR auto has_foreground() const noexcept -> bool {
|
||||
return set_foreground_color;
|
||||
}
|
||||
FMT_CONSTEXPR auto has_background() const noexcept -> bool {
|
||||
return set_background_color;
|
||||
}
|
||||
FMT_CONSTEXPR auto has_emphasis() const noexcept -> bool {
|
||||
return static_cast<uint8_t>(ems) != 0;
|
||||
}
|
||||
FMT_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type {
|
||||
FMT_ASSERT(has_foreground(), "no foreground specified for this style");
|
||||
return foreground_color;
|
||||
}
|
||||
FMT_CONSTEXPR auto get_background() const noexcept -> detail::color_type {
|
||||
FMT_ASSERT(has_background(), "no background specified for this style");
|
||||
return background_color;
|
||||
}
|
||||
FMT_CONSTEXPR auto get_emphasis() const noexcept -> emphasis {
|
||||
FMT_ASSERT(has_emphasis(), "no emphasis specified for this style");
|
||||
return ems;
|
||||
}
|
||||
|
||||
private:
|
||||
FMT_CONSTEXPR text_style(bool is_foreground,
|
||||
detail::color_type text_color) noexcept
|
||||
: set_foreground_color(), set_background_color(), ems() {
|
||||
if (is_foreground) {
|
||||
foreground_color = text_color;
|
||||
set_foreground_color = true;
|
||||
} else {
|
||||
background_color = text_color;
|
||||
set_background_color = true;
|
||||
}
|
||||
}
|
||||
|
||||
friend FMT_CONSTEXPR auto fg(detail::color_type foreground) noexcept
|
||||
-> text_style;
|
||||
|
||||
friend FMT_CONSTEXPR auto bg(detail::color_type background) noexcept
|
||||
-> text_style;
|
||||
|
||||
detail::color_type foreground_color;
|
||||
detail::color_type background_color;
|
||||
bool set_foreground_color;
|
||||
bool set_background_color;
|
||||
emphasis ems;
|
||||
};
|
||||
|
||||
/// Creates a text style from the foreground (text) color.
|
||||
FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept
|
||||
-> text_style {
|
||||
return text_style(true, foreground);
|
||||
}
|
||||
|
||||
/// Creates a text style from the background color.
|
||||
FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept
|
||||
-> text_style {
|
||||
return text_style(false, background);
|
||||
}
|
||||
|
||||
FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept
|
||||
-> text_style {
|
||||
return text_style(lhs) | rhs;
|
||||
}
|
||||
|
||||
namespace detail {
|
||||
|
||||
template <typename Char> struct ansi_color_escape {
|
||||
FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color,
|
||||
const char* esc) noexcept {
|
||||
// If we have a terminal color, we need to output another escape code
|
||||
// sequence.
|
||||
if (!text_color.is_rgb) {
|
||||
bool is_background = esc == string_view("\x1b[48;2;");
|
||||
uint32_t value = text_color.value.term_color;
|
||||
// Background ASCII codes are the same as the foreground ones but with
|
||||
// 10 more.
|
||||
if (is_background) value += 10u;
|
||||
|
||||
size_t index = 0;
|
||||
buffer[index++] = static_cast<Char>('\x1b');
|
||||
buffer[index++] = static_cast<Char>('[');
|
||||
|
||||
if (value >= 100u) {
|
||||
buffer[index++] = static_cast<Char>('1');
|
||||
value %= 100u;
|
||||
}
|
||||
buffer[index++] = static_cast<Char>('0' + value / 10u);
|
||||
buffer[index++] = static_cast<Char>('0' + value % 10u);
|
||||
|
||||
buffer[index++] = static_cast<Char>('m');
|
||||
buffer[index++] = static_cast<Char>('\0');
|
||||
return;
|
||||
}
|
||||
|
||||
for (int i = 0; i < 7; i++) {
|
||||
buffer[i] = static_cast<Char>(esc[i]);
|
||||
}
|
||||
rgb color(text_color.value.rgb_color);
|
||||
to_esc(color.r, buffer + 7, ';');
|
||||
to_esc(color.g, buffer + 11, ';');
|
||||
to_esc(color.b, buffer + 15, 'm');
|
||||
buffer[19] = static_cast<Char>(0);
|
||||
}
|
||||
FMT_CONSTEXPR ansi_color_escape(emphasis em) noexcept {
|
||||
uint8_t em_codes[num_emphases] = {};
|
||||
if (has_emphasis(em, emphasis::bold)) em_codes[0] = 1;
|
||||
if (has_emphasis(em, emphasis::faint)) em_codes[1] = 2;
|
||||
if (has_emphasis(em, emphasis::italic)) em_codes[2] = 3;
|
||||
if (has_emphasis(em, emphasis::underline)) em_codes[3] = 4;
|
||||
if (has_emphasis(em, emphasis::blink)) em_codes[4] = 5;
|
||||
if (has_emphasis(em, emphasis::reverse)) em_codes[5] = 7;
|
||||
if (has_emphasis(em, emphasis::conceal)) em_codes[6] = 8;
|
||||
if (has_emphasis(em, emphasis::strikethrough)) em_codes[7] = 9;
|
||||
|
||||
size_t index = 0;
|
||||
for (size_t i = 0; i < num_emphases; ++i) {
|
||||
if (!em_codes[i]) continue;
|
||||
buffer[index++] = static_cast<Char>('\x1b');
|
||||
buffer[index++] = static_cast<Char>('[');
|
||||
buffer[index++] = static_cast<Char>('0' + em_codes[i]);
|
||||
buffer[index++] = static_cast<Char>('m');
|
||||
}
|
||||
buffer[index++] = static_cast<Char>(0);
|
||||
}
|
||||
FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; }
|
||||
|
||||
FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; }
|
||||
FMT_CONSTEXPR20 auto end() const noexcept -> const Char* {
|
||||
return buffer + basic_string_view<Char>(buffer).size();
|
||||
}
|
||||
|
||||
private:
|
||||
static constexpr size_t num_emphases = 8;
|
||||
Char buffer[7u + 3u * num_emphases + 1u];
|
||||
|
||||
static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out,
|
||||
char delimiter) noexcept {
|
||||
out[0] = static_cast<Char>('0' + c / 100);
|
||||
out[1] = static_cast<Char>('0' + c / 10 % 10);
|
||||
out[2] = static_cast<Char>('0' + c % 10);
|
||||
out[3] = static_cast<Char>(delimiter);
|
||||
}
|
||||
static FMT_CONSTEXPR auto has_emphasis(emphasis em, emphasis mask) noexcept
|
||||
-> bool {
|
||||
return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Char>
|
||||
FMT_CONSTEXPR auto make_foreground_color(detail::color_type foreground) noexcept
|
||||
-> ansi_color_escape<Char> {
|
||||
return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
|
||||
}
|
||||
|
||||
template <typename Char>
|
||||
FMT_CONSTEXPR auto make_background_color(detail::color_type background) noexcept
|
||||
-> ansi_color_escape<Char> {
|
||||
return ansi_color_escape<Char>(background, "\x1b[48;2;");
|
||||
}
|
||||
|
||||
template <typename Char>
|
||||
FMT_CONSTEXPR auto make_emphasis(emphasis em) noexcept
|
||||
-> ansi_color_escape<Char> {
|
||||
return ansi_color_escape<Char>(em);
|
||||
}
|
||||
|
||||
template <typename Char> inline void reset_color(buffer<Char>& buffer) {
|
||||
auto reset_color = string_view("\x1b[0m");
|
||||
buffer.append(reset_color.begin(), reset_color.end());
|
||||
}
|
||||
|
||||
template <typename T> struct styled_arg : detail::view {
|
||||
const T& value;
|
||||
text_style style;
|
||||
styled_arg(const T& v, text_style s) : value(v), style(s) {}
|
||||
};
|
||||
|
||||
template <typename Char>
|
||||
void vformat_to(
|
||||
buffer<Char>& buf, const text_style& ts, basic_string_view<Char> format_str,
|
||||
basic_format_args<buffered_context<type_identity_t<Char>>> args) {
|
||||
bool has_style = false;
|
||||
if (ts.has_emphasis()) {
|
||||
has_style = true;
|
||||
auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
|
||||
buf.append(emphasis.begin(), emphasis.end());
|
||||
}
|
||||
if (ts.has_foreground()) {
|
||||
has_style = true;
|
||||
auto foreground = detail::make_foreground_color<Char>(ts.get_foreground());
|
||||
buf.append(foreground.begin(), foreground.end());
|
||||
}
|
||||
if (ts.has_background()) {
|
||||
has_style = true;
|
||||
auto background = detail::make_background_color<Char>(ts.get_background());
|
||||
buf.append(background.begin(), background.end());
|
||||
}
|
||||
detail::vformat_to(buf, format_str, args, {});
|
||||
if (has_style) detail::reset_color<Char>(buf);
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
inline void vprint(FILE* f, const text_style& ts, string_view fmt,
|
||||
format_args args) {
|
||||
auto buf = memory_buffer();
|
||||
detail::vformat_to(buf, ts, fmt, args);
|
||||
print(f, FMT_STRING("{}"), string_view(buf.begin(), buf.size()));
|
||||
}
|
||||
|
||||
/**
|
||||
* Formats a string and prints it to the specified file stream using ANSI
|
||||
* escape sequences to specify text formatting.
|
||||
*
|
||||
* **Example**:
|
||||
*
|
||||
* fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
|
||||
* "Elapsed time: {0:.2f} seconds", 1.23);
|
||||
*/
|
||||
template <typename... T>
|
||||
void print(FILE* f, const text_style& ts, format_string<T...> fmt,
|
||||
T&&... args) {
|
||||
vprint(f, ts, fmt, fmt::make_format_args(args...));
|
||||
}
|
||||
|
||||
/**
|
||||
* Formats a string and prints it to stdout using ANSI escape sequences to
|
||||
* specify text formatting.
|
||||
*
|
||||
* **Example**:
|
||||
*
|
||||
* fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
|
||||
* "Elapsed time: {0:.2f} seconds", 1.23);
|
||||
*/
|
||||
template <typename... T>
|
||||
void print(const text_style& ts, format_string<T...> fmt, T&&... args) {
|
||||
return print(stdout, ts, fmt, std::forward<T>(args)...);
|
||||
}
|
||||
|
||||
inline auto vformat(const text_style& ts, string_view fmt, format_args args)
|
||||
-> std::string {
|
||||
auto buf = memory_buffer();
|
||||
detail::vformat_to(buf, ts, fmt, args);
|
||||
return fmt::to_string(buf);
|
||||
}
|
||||
|
||||
/**
|
||||
* Formats arguments and returns the result as a string using ANSI escape
|
||||
* sequences to specify text formatting.
|
||||
*
|
||||
* **Example**:
|
||||
*
|
||||
* ```
|
||||
* #include <fmt/color.h>
|
||||
* std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
|
||||
* "The answer is {}", 42);
|
||||
* ```
|
||||
*/
|
||||
template <typename... T>
|
||||
inline auto format(const text_style& ts, format_string<T...> fmt, T&&... args)
|
||||
-> std::string {
|
||||
return fmt::vformat(ts, fmt, fmt::make_format_args(args...));
|
||||
}
|
||||
|
||||
/// Formats a string with the given text_style and writes the output to `out`.
|
||||
template <typename OutputIt,
|
||||
FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
|
||||
auto vformat_to(OutputIt out, const text_style& ts, string_view fmt,
|
||||
format_args args) -> OutputIt {
|
||||
auto&& buf = detail::get_buffer<char>(out);
|
||||
detail::vformat_to(buf, ts, fmt, args);
|
||||
return detail::get_iterator(buf, out);
|
||||
}
|
||||
|
||||
/**
|
||||
* Formats arguments with the given text style, writes the result to the output
|
||||
* iterator `out` and returns the iterator past the end of the output range.
|
||||
*
|
||||
* **Example**:
|
||||
*
|
||||
* std::vector<char> out;
|
||||
* fmt::format_to(std::back_inserter(out),
|
||||
* fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);
|
||||
*/
|
||||
template <typename OutputIt, typename... T,
|
||||
FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
|
||||
inline auto format_to(OutputIt out, const text_style& ts,
|
||||
format_string<T...> fmt, T&&... args) -> OutputIt {
|
||||
return vformat_to(out, ts, fmt, fmt::make_format_args(args...));
|
||||
}
|
||||
|
||||
template <typename T, typename Char>
|
||||
struct formatter<detail::styled_arg<T>, Char> : formatter<T, Char> {
|
||||
template <typename FormatContext>
|
||||
auto format(const detail::styled_arg<T>& arg, FormatContext& ctx) const
|
||||
-> decltype(ctx.out()) {
|
||||
const auto& ts = arg.style;
|
||||
const auto& value = arg.value;
|
||||
auto out = ctx.out();
|
||||
|
||||
bool has_style = false;
|
||||
if (ts.has_emphasis()) {
|
||||
has_style = true;
|
||||
auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
|
||||
out = std::copy(emphasis.begin(), emphasis.end(), out);
|
||||
}
|
||||
if (ts.has_foreground()) {
|
||||
has_style = true;
|
||||
auto foreground =
|
||||
detail::make_foreground_color<Char>(ts.get_foreground());
|
||||
out = std::copy(foreground.begin(), foreground.end(), out);
|
||||
}
|
||||
if (ts.has_background()) {
|
||||
has_style = true;
|
||||
auto background =
|
||||
detail::make_background_color<Char>(ts.get_background());
|
||||
out = std::copy(background.begin(), background.end(), out);
|
||||
}
|
||||
out = formatter<T, Char>::format(value, ctx);
|
||||
if (has_style) {
|
||||
auto reset_color = string_view("\x1b[0m");
|
||||
out = std::copy(reset_color.begin(), reset_color.end(), out);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns an argument that will be formatted using ANSI escape sequences,
|
||||
* to be used in a formatting function.
|
||||
*
|
||||
* **Example**:
|
||||
*
|
||||
* fmt::print("Elapsed time: {0:.2f} seconds",
|
||||
* fmt::styled(1.23, fmt::fg(fmt::color::green) |
|
||||
* fmt::bg(fmt::color::blue)));
|
||||
*/
|
||||
template <typename T>
|
||||
FMT_CONSTEXPR auto styled(const T& value, text_style ts)
|
||||
-> detail::styled_arg<remove_cvref_t<T>> {
|
||||
return detail::styled_arg<remove_cvref_t<T>>{value, ts};
|
||||
}
|
||||
|
||||
FMT_END_EXPORT
|
||||
FMT_END_NAMESPACE
|
||||
|
||||
#endif // FMT_COLOR_H_
|
||||
|
|
@ -0,0 +1,529 @@
|
|||
// Formatting library for C++ - experimental format string compilation
|
||||
//
|
||||
// Copyright (c) 2012 - present, Victor Zverovich and fmt contributors
|
||||
// All rights reserved.
|
||||
//
|
||||
// For the license information refer to format.h.
|
||||
|
||||
#ifndef FMT_COMPILE_H_
|
||||
#define FMT_COMPILE_H_
|
||||
|
||||
#ifndef FMT_MODULE
|
||||
# include <iterator> // std::back_inserter
|
||||
#endif
|
||||
|
||||
#include "format.h"
|
||||
|
||||
FMT_BEGIN_NAMESPACE
|
||||
|
||||
// A compile-time string which is compiled into fast formatting code.
|
||||
FMT_EXPORT class compiled_string {};
|
||||
|
||||
namespace detail {
|
||||
|
||||
template <typename T, typename InputIt>
|
||||
FMT_CONSTEXPR inline auto copy(InputIt begin, InputIt end, counting_iterator it)
|
||||
-> counting_iterator {
|
||||
return it + (end - begin);
|
||||
}
|
||||
|
||||
template <typename S>
|
||||
struct is_compiled_string : std::is_base_of<compiled_string, S> {};
|
||||
|
||||
/**
|
||||
* Converts a string literal `s` into a format string that will be parsed at
|
||||
* compile time and converted into efficient formatting code. Requires C++17
|
||||
* `constexpr if` compiler support.
|
||||
*
|
||||
* **Example**:
|
||||
*
|
||||
* // Converts 42 into std::string using the most efficient method and no
|
||||
* // runtime format string processing.
|
||||
* std::string s = fmt::format(FMT_COMPILE("{}"), 42);
|
||||
*/
|
||||
#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
|
||||
# define FMT_COMPILE(s) FMT_STRING_IMPL(s, fmt::compiled_string, explicit)
|
||||
#else
|
||||
# define FMT_COMPILE(s) FMT_STRING(s)
|
||||
#endif
|
||||
|
||||
#if FMT_USE_NONTYPE_TEMPLATE_ARGS
|
||||
template <typename Char, size_t N,
|
||||
fmt::detail_exported::fixed_string<Char, N> Str>
|
||||
struct udl_compiled_string : compiled_string {
|
||||
using char_type = Char;
|
||||
explicit constexpr operator basic_string_view<char_type>() const {
|
||||
return {Str.data, N - 1};
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
||||
template <typename T, typename... Tail>
|
||||
auto first(const T& value, const Tail&...) -> const T& {
|
||||
return value;
|
||||
}
|
||||
|
||||
#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
|
||||
template <typename... Args> struct type_list {};
|
||||
|
||||
// Returns a reference to the argument at index N from [first, rest...].
|
||||
template <int N, typename T, typename... Args>
|
||||
constexpr const auto& get([[maybe_unused]] const T& first,
|
||||
[[maybe_unused]] const Args&... rest) {
|
||||
static_assert(N < 1 + sizeof...(Args), "index is out of bounds");
|
||||
if constexpr (N == 0)
|
||||
return first;
|
||||
else
|
||||
return detail::get<N - 1>(rest...);
|
||||
}
|
||||
|
||||
template <typename Char, typename... Args>
|
||||
constexpr int get_arg_index_by_name(basic_string_view<Char> name,
|
||||
type_list<Args...>) {
|
||||
return get_arg_index_by_name<Args...>(name);
|
||||
}
|
||||
|
||||
template <int N, typename> struct get_type_impl;
|
||||
|
||||
template <int N, typename... Args> struct get_type_impl<N, type_list<Args...>> {
|
||||
using type =
|
||||
remove_cvref_t<decltype(detail::get<N>(std::declval<Args>()...))>;
|
||||
};
|
||||
|
||||
template <int N, typename T>
|
||||
using get_type = typename get_type_impl<N, T>::type;
|
||||
|
||||
template <typename T> struct is_compiled_format : std::false_type {};
|
||||
|
||||
template <typename Char> struct text {
|
||||
basic_string_view<Char> data;
|
||||
using char_type = Char;
|
||||
|
||||
template <typename OutputIt, typename... Args>
|
||||
constexpr OutputIt format(OutputIt out, const Args&...) const {
|
||||
return write<Char>(out, data);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Char>
|
||||
struct is_compiled_format<text<Char>> : std::true_type {};
|
||||
|
||||
template <typename Char>
|
||||
constexpr text<Char> make_text(basic_string_view<Char> s, size_t pos,
|
||||
size_t size) {
|
||||
return {{&s[pos], size}};
|
||||
}
|
||||
|
||||
template <typename Char> struct code_unit {
|
||||
Char value;
|
||||
using char_type = Char;
|
||||
|
||||
template <typename OutputIt, typename... Args>
|
||||
constexpr OutputIt format(OutputIt out, const Args&...) const {
|
||||
*out++ = value;
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
// This ensures that the argument type is convertible to `const T&`.
|
||||
template <typename T, int N, typename... Args>
|
||||
constexpr const T& get_arg_checked(const Args&... args) {
|
||||
const auto& arg = detail::get<N>(args...);
|
||||
if constexpr (detail::is_named_arg<remove_cvref_t<decltype(arg)>>()) {
|
||||
return arg.value;
|
||||
} else {
|
||||
return arg;
|
||||
}
|
||||
}
|
||||
|
||||
template <typename Char>
|
||||
struct is_compiled_format<code_unit<Char>> : std::true_type {};
|
||||
|
||||
// A replacement field that refers to argument N.
|
||||
template <typename Char, typename T, int N> struct field {
|
||||
using char_type = Char;
|
||||
|
||||
template <typename OutputIt, typename... Args>
|
||||
constexpr OutputIt format(OutputIt out, const Args&... args) const {
|
||||
const T& arg = get_arg_checked<T, N>(args...);
|
||||
if constexpr (std::is_convertible<T, basic_string_view<Char>>::value) {
|
||||
auto s = basic_string_view<Char>(arg);
|
||||
return copy<Char>(s.begin(), s.end(), out);
|
||||
}
|
||||
return write<Char>(out, arg);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Char, typename T, int N>
|
||||
struct is_compiled_format<field<Char, T, N>> : std::true_type {};
|
||||
|
||||
// A replacement field that refers to argument with name.
|
||||
template <typename Char> struct runtime_named_field {
|
||||
using char_type = Char;
|
||||
basic_string_view<Char> name;
|
||||
|
||||
template <typename OutputIt, typename T>
|
||||
constexpr static bool try_format_argument(
|
||||
OutputIt& out,
|
||||
// [[maybe_unused]] due to unused-but-set-parameter warning in GCC 7,8,9
|
||||
[[maybe_unused]] basic_string_view<Char> arg_name, const T& arg) {
|
||||
if constexpr (is_named_arg<typename std::remove_cv<T>::type>::value) {
|
||||
if (arg_name == arg.name) {
|
||||
out = write<Char>(out, arg.value);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
template <typename OutputIt, typename... Args>
|
||||
constexpr OutputIt format(OutputIt out, const Args&... args) const {
|
||||
bool found = (try_format_argument(out, name, args) || ...);
|
||||
if (!found) {
|
||||
FMT_THROW(format_error("argument with specified name is not found"));
|
||||
}
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Char>
|
||||
struct is_compiled_format<runtime_named_field<Char>> : std::true_type {};
|
||||
|
||||
// A replacement field that refers to argument N and has format specifiers.
|
||||
template <typename Char, typename T, int N> struct spec_field {
|
||||
using char_type = Char;
|
||||
formatter<T, Char> fmt;
|
||||
|
||||
template <typename OutputIt, typename... Args>
|
||||
constexpr FMT_INLINE OutputIt format(OutputIt out,
|
||||
const Args&... args) const {
|
||||
const auto& vargs =
|
||||
fmt::make_format_args<basic_format_context<OutputIt, Char>>(args...);
|
||||
basic_format_context<OutputIt, Char> ctx(out, vargs);
|
||||
return fmt.format(get_arg_checked<T, N>(args...), ctx);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Char, typename T, int N>
|
||||
struct is_compiled_format<spec_field<Char, T, N>> : std::true_type {};
|
||||
|
||||
template <typename L, typename R> struct concat {
|
||||
L lhs;
|
||||
R rhs;
|
||||
using char_type = typename L::char_type;
|
||||
|
||||
template <typename OutputIt, typename... Args>
|
||||
constexpr OutputIt format(OutputIt out, const Args&... args) const {
|
||||
out = lhs.format(out, args...);
|
||||
return rhs.format(out, args...);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename L, typename R>
|
||||
struct is_compiled_format<concat<L, R>> : std::true_type {};
|
||||
|
||||
template <typename L, typename R>
|
||||
constexpr concat<L, R> make_concat(L lhs, R rhs) {
|
||||
return {lhs, rhs};
|
||||
}
|
||||
|
||||
struct unknown_format {};
|
||||
|
||||
template <typename Char>
|
||||
constexpr size_t parse_text(basic_string_view<Char> str, size_t pos) {
|
||||
for (size_t size = str.size(); pos != size; ++pos) {
|
||||
if (str[pos] == '{' || str[pos] == '}') break;
|
||||
}
|
||||
return pos;
|
||||
}
|
||||
|
||||
template <typename Args, size_t POS, int ID, typename S>
|
||||
constexpr auto compile_format_string(S fmt);
|
||||
|
||||
template <typename Args, size_t POS, int ID, typename T, typename S>
|
||||
constexpr auto parse_tail(T head, S fmt) {
|
||||
if constexpr (POS != basic_string_view<typename S::char_type>(fmt).size()) {
|
||||
constexpr auto tail = compile_format_string<Args, POS, ID>(fmt);
|
||||
if constexpr (std::is_same<remove_cvref_t<decltype(tail)>,
|
||||
unknown_format>())
|
||||
return tail;
|
||||
else
|
||||
return make_concat(head, tail);
|
||||
} else {
|
||||
return head;
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T, typename Char> struct parse_specs_result {
|
||||
formatter<T, Char> fmt;
|
||||
size_t end;
|
||||
int next_arg_id;
|
||||
};
|
||||
|
||||
enum { manual_indexing_id = -1 };
|
||||
|
||||
template <typename T, typename Char>
|
||||
constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
|
||||
size_t pos, int next_arg_id) {
|
||||
str.remove_prefix(pos);
|
||||
auto ctx =
|
||||
compile_parse_context<Char>(str, max_value<int>(), nullptr, next_arg_id);
|
||||
auto f = formatter<T, Char>();
|
||||
auto end = f.parse(ctx);
|
||||
return {f, pos + fmt::detail::to_unsigned(end - str.data()),
|
||||
next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()};
|
||||
}
|
||||
|
||||
template <typename Char> struct arg_id_handler {
|
||||
arg_ref<Char> arg_id;
|
||||
|
||||
constexpr int on_auto() {
|
||||
FMT_ASSERT(false, "handler cannot be used with automatic indexing");
|
||||
return 0;
|
||||
}
|
||||
constexpr int on_index(int id) {
|
||||
arg_id = arg_ref<Char>(id);
|
||||
return 0;
|
||||
}
|
||||
constexpr int on_name(basic_string_view<Char> id) {
|
||||
arg_id = arg_ref<Char>(id);
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Char> struct parse_arg_id_result {
|
||||
arg_ref<Char> arg_id;
|
||||
const Char* arg_id_end;
|
||||
};
|
||||
|
||||
template <int ID, typename Char>
|
||||
constexpr auto parse_arg_id(const Char* begin, const Char* end) {
|
||||
auto handler = arg_id_handler<Char>{arg_ref<Char>{}};
|
||||
auto arg_id_end = parse_arg_id(begin, end, handler);
|
||||
return parse_arg_id_result<Char>{handler.arg_id, arg_id_end};
|
||||
}
|
||||
|
||||
template <typename T, typename Enable = void> struct field_type {
|
||||
using type = remove_cvref_t<T>;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct field_type<T, enable_if_t<detail::is_named_arg<T>::value>> {
|
||||
using type = remove_cvref_t<decltype(T::value)>;
|
||||
};
|
||||
|
||||
template <typename T, typename Args, size_t END_POS, int ARG_INDEX, int NEXT_ID,
|
||||
typename S>
|
||||
constexpr auto parse_replacement_field_then_tail(S fmt) {
|
||||
using char_type = typename S::char_type;
|
||||
constexpr auto str = basic_string_view<char_type>(fmt);
|
||||
constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type();
|
||||
if constexpr (c == '}') {
|
||||
return parse_tail<Args, END_POS + 1, NEXT_ID>(
|
||||
field<char_type, typename field_type<T>::type, ARG_INDEX>(), fmt);
|
||||
} else if constexpr (c != ':') {
|
||||
FMT_THROW(format_error("expected ':'"));
|
||||
} else {
|
||||
constexpr auto result = parse_specs<typename field_type<T>::type>(
|
||||
str, END_POS + 1, NEXT_ID == manual_indexing_id ? 0 : NEXT_ID);
|
||||
if constexpr (result.end >= str.size() || str[result.end] != '}') {
|
||||
FMT_THROW(format_error("expected '}'"));
|
||||
return 0;
|
||||
} else {
|
||||
return parse_tail<Args, result.end + 1, result.next_arg_id>(
|
||||
spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{
|
||||
result.fmt},
|
||||
fmt);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Compiles a non-empty format string and returns the compiled representation
|
||||
// or unknown_format() on unrecognized input.
|
||||
template <typename Args, size_t POS, int ID, typename S>
|
||||
constexpr auto compile_format_string(S fmt) {
|
||||
using char_type = typename S::char_type;
|
||||
constexpr auto str = basic_string_view<char_type>(fmt);
|
||||
if constexpr (str[POS] == '{') {
|
||||
if constexpr (POS + 1 == str.size())
|
||||
FMT_THROW(format_error("unmatched '{' in format string"));
|
||||
if constexpr (str[POS + 1] == '{') {
|
||||
return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt);
|
||||
} else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') {
|
||||
static_assert(ID != manual_indexing_id,
|
||||
"cannot switch from manual to automatic argument indexing");
|
||||
constexpr auto next_id =
|
||||
ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
|
||||
return parse_replacement_field_then_tail<get_type<ID, Args>, Args,
|
||||
POS + 1, ID, next_id>(fmt);
|
||||
} else {
|
||||
constexpr auto arg_id_result =
|
||||
parse_arg_id<ID>(str.data() + POS + 1, str.data() + str.size());
|
||||
constexpr auto arg_id_end_pos = arg_id_result.arg_id_end - str.data();
|
||||
constexpr char_type c =
|
||||
arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type();
|
||||
static_assert(c == '}' || c == ':', "missing '}' in format string");
|
||||
if constexpr (arg_id_result.arg_id.kind == arg_id_kind::index) {
|
||||
static_assert(
|
||||
ID == manual_indexing_id || ID == 0,
|
||||
"cannot switch from automatic to manual argument indexing");
|
||||
constexpr auto arg_index = arg_id_result.arg_id.val.index;
|
||||
return parse_replacement_field_then_tail<get_type<arg_index, Args>,
|
||||
Args, arg_id_end_pos,
|
||||
arg_index, manual_indexing_id>(
|
||||
fmt);
|
||||
} else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) {
|
||||
constexpr auto arg_index =
|
||||
get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{});
|
||||
if constexpr (arg_index >= 0) {
|
||||
constexpr auto next_id =
|
||||
ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
|
||||
return parse_replacement_field_then_tail<
|
||||
decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos,
|
||||
arg_index, next_id>(fmt);
|
||||
} else if constexpr (c == '}') {
|
||||
return parse_tail<Args, arg_id_end_pos + 1, ID>(
|
||||
runtime_named_field<char_type>{arg_id_result.arg_id.val.name},
|
||||
fmt);
|
||||
} else if constexpr (c == ':') {
|
||||
return unknown_format(); // no type info for specs parsing
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if constexpr (str[POS] == '}') {
|
||||
if constexpr (POS + 1 == str.size())
|
||||
FMT_THROW(format_error("unmatched '}' in format string"));
|
||||
return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt);
|
||||
} else {
|
||||
constexpr auto end = parse_text(str, POS + 1);
|
||||
if constexpr (end - POS > 1) {
|
||||
return parse_tail<Args, end, ID>(make_text(str, POS, end - POS), fmt);
|
||||
} else {
|
||||
return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]}, fmt);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template <typename... Args, typename S,
|
||||
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
|
||||
constexpr auto compile(S fmt) {
|
||||
constexpr auto str = basic_string_view<typename S::char_type>(fmt);
|
||||
if constexpr (str.size() == 0) {
|
||||
return detail::make_text(str, 0, 0);
|
||||
} else {
|
||||
constexpr auto result =
|
||||
detail::compile_format_string<detail::type_list<Args...>, 0, 0>(fmt);
|
||||
return result;
|
||||
}
|
||||
}
|
||||
#endif // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
|
||||
} // namespace detail
|
||||
|
||||
FMT_BEGIN_EXPORT
|
||||
|
||||
#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
|
||||
|
||||
template <typename CompiledFormat, typename... Args,
|
||||
typename Char = typename CompiledFormat::char_type,
|
||||
FMT_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)>
|
||||
FMT_INLINE std::basic_string<Char> format(const CompiledFormat& cf,
|
||||
const Args&... args) {
|
||||
auto s = std::basic_string<Char>();
|
||||
cf.format(std::back_inserter(s), args...);
|
||||
return s;
|
||||
}
|
||||
|
||||
template <typename OutputIt, typename CompiledFormat, typename... Args,
|
||||
FMT_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)>
|
||||
constexpr FMT_INLINE OutputIt format_to(OutputIt out, const CompiledFormat& cf,
|
||||
const Args&... args) {
|
||||
return cf.format(out, args...);
|
||||
}
|
||||
|
||||
template <typename S, typename... Args,
|
||||
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
|
||||
FMT_INLINE std::basic_string<typename S::char_type> format(const S&,
|
||||
Args&&... args) {
|
||||
if constexpr (std::is_same<typename S::char_type, char>::value) {
|
||||
constexpr auto str = basic_string_view<typename S::char_type>(S());
|
||||
if constexpr (str.size() == 2 && str[0] == '{' && str[1] == '}') {
|
||||
const auto& first = detail::first(args...);
|
||||
if constexpr (detail::is_named_arg<
|
||||
remove_cvref_t<decltype(first)>>::value) {
|
||||
return fmt::to_string(first.value);
|
||||
} else {
|
||||
return fmt::to_string(first);
|
||||
}
|
||||
}
|
||||
}
|
||||
constexpr auto compiled = detail::compile<Args...>(S());
|
||||
if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
|
||||
detail::unknown_format>()) {
|
||||
return fmt::format(
|
||||
static_cast<basic_string_view<typename S::char_type>>(S()),
|
||||
std::forward<Args>(args)...);
|
||||
} else {
|
||||
return fmt::format(compiled, std::forward<Args>(args)...);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename OutputIt, typename S, typename... Args,
|
||||
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
|
||||
FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {
|
||||
constexpr auto compiled = detail::compile<Args...>(S());
|
||||
if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
|
||||
detail::unknown_format>()) {
|
||||
return fmt::format_to(
|
||||
out, static_cast<basic_string_view<typename S::char_type>>(S()),
|
||||
std::forward<Args>(args)...);
|
||||
} else {
|
||||
return fmt::format_to(out, compiled, std::forward<Args>(args)...);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
template <typename OutputIt, typename S, typename... Args,
|
||||
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
|
||||
auto format_to_n(OutputIt out, size_t n, const S& fmt, Args&&... args)
|
||||
-> format_to_n_result<OutputIt> {
|
||||
using traits = detail::fixed_buffer_traits;
|
||||
auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
|
||||
fmt::format_to(std::back_inserter(buf), fmt, std::forward<Args>(args)...);
|
||||
return {buf.out(), buf.count()};
|
||||
}
|
||||
|
||||
template <typename S, typename... Args,
|
||||
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
|
||||
FMT_CONSTEXPR20 auto formatted_size(const S& fmt, const Args&... args)
|
||||
-> size_t {
|
||||
return fmt::format_to(detail::counting_iterator(), fmt, args...).count();
|
||||
}
|
||||
|
||||
template <typename S, typename... Args,
|
||||
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
|
||||
void print(std::FILE* f, const S& fmt, const Args&... args) {
|
||||
memory_buffer buffer;
|
||||
fmt::format_to(std::back_inserter(buffer), fmt, args...);
|
||||
detail::print(f, {buffer.data(), buffer.size()});
|
||||
}
|
||||
|
||||
template <typename S, typename... Args,
|
||||
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
|
||||
void print(const S& fmt, const Args&... args) {
|
||||
print(stdout, fmt, args...);
|
||||
}
|
||||
|
||||
#if FMT_USE_NONTYPE_TEMPLATE_ARGS
|
||||
inline namespace literals {
|
||||
template <detail_exported::fixed_string Str> constexpr auto operator""_cf() {
|
||||
using char_t = remove_cvref_t<decltype(Str.data[0])>;
|
||||
return detail::udl_compiled_string<char_t, sizeof(Str.data) / sizeof(char_t),
|
||||
Str>();
|
||||
}
|
||||
} // namespace literals
|
||||
#endif
|
||||
|
||||
FMT_END_EXPORT
|
||||
FMT_END_NAMESPACE
|
||||
|
||||
#endif // FMT_COMPILE_H_
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
// This file is only provided for compatibility and may be removed in future
|
||||
// versions. Use fmt/base.h if you don't need fmt::format and fmt/format.h
|
||||
// otherwise.
|
||||
|
||||
#include "format.h"
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,439 @@
|
|||
// Formatting library for C++ - optional OS-specific functionality
|
||||
//
|
||||
// Copyright (c) 2012 - present, Victor Zverovich
|
||||
// All rights reserved.
|
||||
//
|
||||
// For the license information refer to format.h.
|
||||
|
||||
#ifndef FMT_OS_H_
|
||||
#define FMT_OS_H_
|
||||
|
||||
#include "format.h"
|
||||
|
||||
#ifndef FMT_MODULE
|
||||
# include <cerrno>
|
||||
# include <cstddef>
|
||||
# include <cstdio>
|
||||
# include <system_error> // std::system_error
|
||||
|
||||
# if FMT_HAS_INCLUDE(<xlocale.h>)
|
||||
# include <xlocale.h> // LC_NUMERIC_MASK on macOS
|
||||
# endif
|
||||
#endif // FMT_MODULE
|
||||
|
||||
#ifndef FMT_USE_FCNTL
|
||||
// UWP doesn't provide _pipe.
|
||||
# if FMT_HAS_INCLUDE("winapifamily.h")
|
||||
# include <winapifamily.h>
|
||||
# endif
|
||||
# if (FMT_HAS_INCLUDE(<fcntl.h>) || defined(__APPLE__) || \
|
||||
defined(__linux__)) && \
|
||||
(!defined(WINAPI_FAMILY) || \
|
||||
(WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
|
||||
# include <fcntl.h> // for O_RDONLY
|
||||
# define FMT_USE_FCNTL 1
|
||||
# else
|
||||
# define FMT_USE_FCNTL 0
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef FMT_POSIX
|
||||
# if defined(_WIN32) && !defined(__MINGW32__)
|
||||
// Fix warnings about deprecated symbols.
|
||||
# define FMT_POSIX(call) _##call
|
||||
# else
|
||||
# define FMT_POSIX(call) call
|
||||
# endif
|
||||
#endif
|
||||
|
||||
// Calls to system functions are wrapped in FMT_SYSTEM for testability.
|
||||
#ifdef FMT_SYSTEM
|
||||
# define FMT_HAS_SYSTEM
|
||||
# define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
|
||||
#else
|
||||
# define FMT_SYSTEM(call) ::call
|
||||
# ifdef _WIN32
|
||||
// Fix warnings about deprecated symbols.
|
||||
# define FMT_POSIX_CALL(call) ::_##call
|
||||
# else
|
||||
# define FMT_POSIX_CALL(call) ::call
|
||||
# endif
|
||||
#endif
|
||||
|
||||
// Retries the expression while it evaluates to error_result and errno
|
||||
// equals to EINTR.
|
||||
#ifndef _WIN32
|
||||
# define FMT_RETRY_VAL(result, expression, error_result) \
|
||||
do { \
|
||||
(result) = (expression); \
|
||||
} while ((result) == (error_result) && errno == EINTR)
|
||||
#else
|
||||
# define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
|
||||
#endif
|
||||
|
||||
#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
|
||||
|
||||
FMT_BEGIN_NAMESPACE
|
||||
FMT_BEGIN_EXPORT
|
||||
|
||||
/**
|
||||
* A reference to a null-terminated string. It can be constructed from a C
|
||||
* string or `std::string`.
|
||||
*
|
||||
* You can use one of the following type aliases for common character types:
|
||||
*
|
||||
* +---------------+-----------------------------+
|
||||
* | Type | Definition |
|
||||
* +===============+=============================+
|
||||
* | cstring_view | basic_cstring_view<char> |
|
||||
* +---------------+-----------------------------+
|
||||
* | wcstring_view | basic_cstring_view<wchar_t> |
|
||||
* +---------------+-----------------------------+
|
||||
*
|
||||
* This class is most useful as a parameter type for functions that wrap C APIs.
|
||||
*/
|
||||
template <typename Char> class basic_cstring_view {
|
||||
private:
|
||||
const Char* data_;
|
||||
|
||||
public:
|
||||
/// Constructs a string reference object from a C string.
|
||||
basic_cstring_view(const Char* s) : data_(s) {}
|
||||
|
||||
/// Constructs a string reference from an `std::string` object.
|
||||
basic_cstring_view(const std::basic_string<Char>& s) : data_(s.c_str()) {}
|
||||
|
||||
/// Returns the pointer to a C string.
|
||||
auto c_str() const -> const Char* { return data_; }
|
||||
};
|
||||
|
||||
using cstring_view = basic_cstring_view<char>;
|
||||
using wcstring_view = basic_cstring_view<wchar_t>;
|
||||
|
||||
#ifdef _WIN32
|
||||
FMT_API const std::error_category& system_category() noexcept;
|
||||
|
||||
namespace detail {
|
||||
FMT_API void format_windows_error(buffer<char>& out, int error_code,
|
||||
const char* message) noexcept;
|
||||
}
|
||||
|
||||
FMT_API std::system_error vwindows_error(int error_code, string_view format_str,
|
||||
format_args args);
|
||||
|
||||
/**
|
||||
* Constructs a `std::system_error` object with the description of the form
|
||||
*
|
||||
* <message>: <system-message>
|
||||
*
|
||||
* where `<message>` is the formatted message and `<system-message>` is the
|
||||
* system message corresponding to the error code.
|
||||
* `error_code` is a Windows error code as given by `GetLastError`.
|
||||
* If `error_code` is not a valid error code such as -1, the system message
|
||||
* will look like "error -1".
|
||||
*
|
||||
* **Example**:
|
||||
*
|
||||
* // This throws a system_error with the description
|
||||
* // cannot open file 'madeup': The system cannot find the file
|
||||
* specified.
|
||||
* // or similar (system message may vary).
|
||||
* const char *filename = "madeup";
|
||||
* LPOFSTRUCT of = LPOFSTRUCT();
|
||||
* HFILE file = OpenFile(filename, &of, OF_READ);
|
||||
* if (file == HFILE_ERROR) {
|
||||
* throw fmt::windows_error(GetLastError(),
|
||||
* "cannot open file '{}'", filename);
|
||||
* }
|
||||
*/
|
||||
template <typename... Args>
|
||||
std::system_error windows_error(int error_code, string_view message,
|
||||
const Args&... args) {
|
||||
return vwindows_error(error_code, message, fmt::make_format_args(args...));
|
||||
}
|
||||
|
||||
// Reports a Windows error without throwing an exception.
|
||||
// Can be used to report errors from destructors.
|
||||
FMT_API void report_windows_error(int error_code, const char* message) noexcept;
|
||||
#else
|
||||
inline auto system_category() noexcept -> const std::error_category& {
|
||||
return std::system_category();
|
||||
}
|
||||
#endif // _WIN32
|
||||
|
||||
// std::system is not available on some platforms such as iOS (#2248).
|
||||
#ifdef __OSX__
|
||||
template <typename S, typename... Args, typename Char = char_t<S>>
|
||||
void say(const S& format_str, Args&&... args) {
|
||||
std::system(format("say \"{}\"", format(format_str, args...)).c_str());
|
||||
}
|
||||
#endif
|
||||
|
||||
// A buffered file.
|
||||
class buffered_file {
|
||||
private:
|
||||
FILE* file_;
|
||||
|
||||
friend class file;
|
||||
|
||||
explicit buffered_file(FILE* f) : file_(f) {}
|
||||
|
||||
public:
|
||||
buffered_file(const buffered_file&) = delete;
|
||||
void operator=(const buffered_file&) = delete;
|
||||
|
||||
// Constructs a buffered_file object which doesn't represent any file.
|
||||
buffered_file() noexcept : file_(nullptr) {}
|
||||
|
||||
// Destroys the object closing the file it represents if any.
|
||||
FMT_API ~buffered_file() noexcept;
|
||||
|
||||
public:
|
||||
buffered_file(buffered_file&& other) noexcept : file_(other.file_) {
|
||||
other.file_ = nullptr;
|
||||
}
|
||||
|
||||
auto operator=(buffered_file&& other) -> buffered_file& {
|
||||
close();
|
||||
file_ = other.file_;
|
||||
other.file_ = nullptr;
|
||||
return *this;
|
||||
}
|
||||
|
||||
// Opens a file.
|
||||
FMT_API buffered_file(cstring_view filename, cstring_view mode);
|
||||
|
||||
// Closes the file.
|
||||
FMT_API void close();
|
||||
|
||||
// Returns the pointer to a FILE object representing this file.
|
||||
auto get() const noexcept -> FILE* { return file_; }
|
||||
|
||||
FMT_API auto descriptor() const -> int;
|
||||
|
||||
template <typename... T>
|
||||
inline void print(string_view fmt, const T&... args) {
|
||||
const auto& vargs = fmt::make_format_args(args...);
|
||||
detail::is_locking<T...>() ? fmt::vprint_buffered(file_, fmt, vargs)
|
||||
: fmt::vprint(file_, fmt, vargs);
|
||||
}
|
||||
};
|
||||
|
||||
#if FMT_USE_FCNTL
|
||||
|
||||
// A file. Closed file is represented by a file object with descriptor -1.
|
||||
// Methods that are not declared with noexcept may throw
|
||||
// fmt::system_error in case of failure. Note that some errors such as
|
||||
// closing the file multiple times will cause a crash on Windows rather
|
||||
// than an exception. You can get standard behavior by overriding the
|
||||
// invalid parameter handler with _set_invalid_parameter_handler.
|
||||
class FMT_API file {
|
||||
private:
|
||||
int fd_; // File descriptor.
|
||||
|
||||
// Constructs a file object with a given descriptor.
|
||||
explicit file(int fd) : fd_(fd) {}
|
||||
|
||||
friend struct pipe;
|
||||
|
||||
public:
|
||||
// Possible values for the oflag argument to the constructor.
|
||||
enum {
|
||||
RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only.
|
||||
WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only.
|
||||
RDWR = FMT_POSIX(O_RDWR), // Open for reading and writing.
|
||||
CREATE = FMT_POSIX(O_CREAT), // Create if the file doesn't exist.
|
||||
APPEND = FMT_POSIX(O_APPEND), // Open in append mode.
|
||||
TRUNC = FMT_POSIX(O_TRUNC) // Truncate the content of the file.
|
||||
};
|
||||
|
||||
// Constructs a file object which doesn't represent any file.
|
||||
file() noexcept : fd_(-1) {}
|
||||
|
||||
// Opens a file and constructs a file object representing this file.
|
||||
file(cstring_view path, int oflag);
|
||||
|
||||
public:
|
||||
file(const file&) = delete;
|
||||
void operator=(const file&) = delete;
|
||||
|
||||
file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }
|
||||
|
||||
// Move assignment is not noexcept because close may throw.
|
||||
auto operator=(file&& other) -> file& {
|
||||
close();
|
||||
fd_ = other.fd_;
|
||||
other.fd_ = -1;
|
||||
return *this;
|
||||
}
|
||||
|
||||
// Destroys the object closing the file it represents if any.
|
||||
~file() noexcept;
|
||||
|
||||
// Returns the file descriptor.
|
||||
auto descriptor() const noexcept -> int { return fd_; }
|
||||
|
||||
// Closes the file.
|
||||
void close();
|
||||
|
||||
// Returns the file size. The size has signed type for consistency with
|
||||
// stat::st_size.
|
||||
auto size() const -> long long;
|
||||
|
||||
// Attempts to read count bytes from the file into the specified buffer.
|
||||
auto read(void* buffer, size_t count) -> size_t;
|
||||
|
||||
// Attempts to write count bytes from the specified buffer to the file.
|
||||
auto write(const void* buffer, size_t count) -> size_t;
|
||||
|
||||
// Duplicates a file descriptor with the dup function and returns
|
||||
// the duplicate as a file object.
|
||||
static auto dup(int fd) -> file;
|
||||
|
||||
// Makes fd be the copy of this file descriptor, closing fd first if
|
||||
// necessary.
|
||||
void dup2(int fd);
|
||||
|
||||
// Makes fd be the copy of this file descriptor, closing fd first if
|
||||
// necessary.
|
||||
void dup2(int fd, std::error_code& ec) noexcept;
|
||||
|
||||
// Creates a buffered_file object associated with this file and detaches
|
||||
// this file object from the file.
|
||||
auto fdopen(const char* mode) -> buffered_file;
|
||||
|
||||
# if defined(_WIN32) && !defined(__MINGW32__)
|
||||
// Opens a file and constructs a file object representing this file by
|
||||
// wcstring_view filename. Windows only.
|
||||
static file open_windows_file(wcstring_view path, int oflag);
|
||||
# endif
|
||||
};
|
||||
|
||||
struct FMT_API pipe {
|
||||
file read_end;
|
||||
file write_end;
|
||||
|
||||
// Creates a pipe setting up read_end and write_end file objects for reading
|
||||
// and writing respectively.
|
||||
pipe();
|
||||
};
|
||||
|
||||
// Returns the memory page size.
|
||||
auto getpagesize() -> long;
|
||||
|
||||
namespace detail {
|
||||
|
||||
struct buffer_size {
|
||||
buffer_size() = default;
|
||||
size_t value = 0;
|
||||
auto operator=(size_t val) const -> buffer_size {
|
||||
auto bs = buffer_size();
|
||||
bs.value = val;
|
||||
return bs;
|
||||
}
|
||||
};
|
||||
|
||||
struct ostream_params {
|
||||
int oflag = file::WRONLY | file::CREATE | file::TRUNC;
|
||||
size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768;
|
||||
|
||||
ostream_params() {}
|
||||
|
||||
template <typename... T>
|
||||
ostream_params(T... params, int new_oflag) : ostream_params(params...) {
|
||||
oflag = new_oflag;
|
||||
}
|
||||
|
||||
template <typename... T>
|
||||
ostream_params(T... params, detail::buffer_size bs)
|
||||
: ostream_params(params...) {
|
||||
this->buffer_size = bs.value;
|
||||
}
|
||||
|
||||
// Intel has a bug that results in failure to deduce a constructor
|
||||
// for empty parameter packs.
|
||||
# if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 2000
|
||||
ostream_params(int new_oflag) : oflag(new_oflag) {}
|
||||
ostream_params(detail::buffer_size bs) : buffer_size(bs.value) {}
|
||||
# endif
|
||||
};
|
||||
|
||||
class file_buffer final : public buffer<char> {
|
||||
private:
|
||||
file file_;
|
||||
|
||||
FMT_API static void grow(buffer<char>& buf, size_t);
|
||||
|
||||
public:
|
||||
FMT_API file_buffer(cstring_view path, const ostream_params& params);
|
||||
FMT_API file_buffer(file_buffer&& other) noexcept;
|
||||
FMT_API ~file_buffer();
|
||||
|
||||
void flush() {
|
||||
if (size() == 0) return;
|
||||
file_.write(data(), size() * sizeof(data()[0]));
|
||||
clear();
|
||||
}
|
||||
|
||||
void close() {
|
||||
flush();
|
||||
file_.close();
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
constexpr auto buffer_size = detail::buffer_size();
|
||||
|
||||
/// A fast output stream for writing from a single thread. Writing from
|
||||
/// multiple threads without external synchronization may result in a data race.
|
||||
class FMT_API ostream {
|
||||
private:
|
||||
FMT_MSC_WARNING(suppress : 4251)
|
||||
detail::file_buffer buffer_;
|
||||
|
||||
ostream(cstring_view path, const detail::ostream_params& params)
|
||||
: buffer_(path, params) {}
|
||||
|
||||
public:
|
||||
ostream(ostream&& other) : buffer_(std::move(other.buffer_)) {}
|
||||
|
||||
~ostream();
|
||||
|
||||
void flush() { buffer_.flush(); }
|
||||
|
||||
template <typename... T>
|
||||
friend auto output_file(cstring_view path, T... params) -> ostream;
|
||||
|
||||
void close() { buffer_.close(); }
|
||||
|
||||
/// Formats `args` according to specifications in `fmt` and writes the
|
||||
/// output to the file.
|
||||
template <typename... T> void print(format_string<T...> fmt, T&&... args) {
|
||||
vformat_to(appender(buffer_), fmt, fmt::make_format_args(args...));
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Opens a file for writing. Supported parameters passed in `params`:
|
||||
*
|
||||
* - `<integer>`: Flags passed to [open](
|
||||
* https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html)
|
||||
* (`file::WRONLY | file::CREATE | file::TRUNC` by default)
|
||||
* - `buffer_size=<integer>`: Output buffer size
|
||||
*
|
||||
* **Example**:
|
||||
*
|
||||
* auto out = fmt::output_file("guide.txt");
|
||||
* out.print("Don't {}", "Panic");
|
||||
*/
|
||||
template <typename... T>
|
||||
inline auto output_file(cstring_view path, T... params) -> ostream {
|
||||
return {path, detail::ostream_params(params...)};
|
||||
}
|
||||
#endif // FMT_USE_FCNTL
|
||||
|
||||
FMT_END_EXPORT
|
||||
FMT_END_NAMESPACE
|
||||
|
||||
#endif // FMT_OS_H_
|
||||
|
|
@ -0,0 +1,211 @@
|
|||
// Formatting library for C++ - std::ostream support
|
||||
//
|
||||
// Copyright (c) 2012 - present, Victor Zverovich
|
||||
// All rights reserved.
|
||||
//
|
||||
// For the license information refer to format.h.
|
||||
|
||||
#ifndef FMT_OSTREAM_H_
|
||||
#define FMT_OSTREAM_H_
|
||||
|
||||
#ifndef FMT_MODULE
|
||||
# include <fstream> // std::filebuf
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
# ifdef __GLIBCXX__
|
||||
# include <ext/stdio_filebuf.h>
|
||||
# include <ext/stdio_sync_filebuf.h>
|
||||
# endif
|
||||
# include <io.h>
|
||||
#endif
|
||||
|
||||
#include "chrono.h" // formatbuf
|
||||
|
||||
FMT_BEGIN_NAMESPACE
|
||||
namespace detail {
|
||||
|
||||
// Generate a unique explicit instantion in every translation unit using a tag
|
||||
// type in an anonymous namespace.
|
||||
namespace {
|
||||
struct file_access_tag {};
|
||||
} // namespace
|
||||
template <typename Tag, typename BufType, FILE* BufType::*FileMemberPtr>
|
||||
class file_access {
|
||||
friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; }
|
||||
};
|
||||
|
||||
#if FMT_MSC_VERSION
|
||||
template class file_access<file_access_tag, std::filebuf,
|
||||
&std::filebuf::_Myfile>;
|
||||
auto get_file(std::filebuf&) -> FILE*;
|
||||
#endif
|
||||
|
||||
inline auto write_ostream_unicode(std::ostream& os, fmt::string_view data)
|
||||
-> bool {
|
||||
FILE* f = nullptr;
|
||||
#if FMT_MSC_VERSION && FMT_USE_RTTI
|
||||
if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
|
||||
f = get_file(*buf);
|
||||
else
|
||||
return false;
|
||||
#elif defined(_WIN32) && defined(__GLIBCXX__) && FMT_USE_RTTI
|
||||
auto* rdbuf = os.rdbuf();
|
||||
if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
|
||||
f = sfbuf->file();
|
||||
else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
|
||||
f = fbuf->file();
|
||||
else
|
||||
return false;
|
||||
#else
|
||||
ignore_unused(os, data, f);
|
||||
#endif
|
||||
#ifdef _WIN32
|
||||
if (f) {
|
||||
int fd = _fileno(f);
|
||||
if (_isatty(fd)) {
|
||||
os.flush();
|
||||
return write_console(fd, data);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
inline auto write_ostream_unicode(std::wostream&,
|
||||
fmt::basic_string_view<wchar_t>) -> bool {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Write the content of buf to os.
|
||||
// It is a separate function rather than a part of vprint to simplify testing.
|
||||
template <typename Char>
|
||||
void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
|
||||
const Char* buf_data = buf.data();
|
||||
using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
|
||||
unsigned_streamsize size = buf.size();
|
||||
unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
|
||||
do {
|
||||
unsigned_streamsize n = size <= max_size ? size : max_size;
|
||||
os.write(buf_data, static_cast<std::streamsize>(n));
|
||||
buf_data += n;
|
||||
size -= n;
|
||||
} while (size != 0);
|
||||
}
|
||||
|
||||
template <typename Char, typename T>
|
||||
void format_value(buffer<Char>& buf, const T& value) {
|
||||
auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
|
||||
auto&& output = std::basic_ostream<Char>(&format_buf);
|
||||
#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
|
||||
output.imbue(std::locale::classic()); // The default is always unlocalized.
|
||||
#endif
|
||||
output << value;
|
||||
output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
|
||||
}
|
||||
|
||||
template <typename T> struct streamed_view {
|
||||
const T& value;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// Formats an object of type T that has an overloaded ostream operator<<.
|
||||
template <typename Char>
|
||||
struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> {
|
||||
void set_debug_format() = delete;
|
||||
|
||||
template <typename T, typename Context>
|
||||
auto format(const T& value, Context& ctx) const -> decltype(ctx.out()) {
|
||||
auto buffer = basic_memory_buffer<Char>();
|
||||
detail::format_value(buffer, value);
|
||||
return formatter<basic_string_view<Char>, Char>::format(
|
||||
{buffer.data(), buffer.size()}, ctx);
|
||||
}
|
||||
};
|
||||
|
||||
using ostream_formatter = basic_ostream_formatter<char>;
|
||||
|
||||
template <typename T, typename Char>
|
||||
struct formatter<detail::streamed_view<T>, Char>
|
||||
: basic_ostream_formatter<Char> {
|
||||
template <typename Context>
|
||||
auto format(detail::streamed_view<T> view, Context& ctx) const
|
||||
-> decltype(ctx.out()) {
|
||||
return basic_ostream_formatter<Char>::format(view.value, ctx);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns a view that formats `value` via an ostream `operator<<`.
|
||||
*
|
||||
* **Example**:
|
||||
*
|
||||
* fmt::print("Current thread id: {}\n",
|
||||
* fmt::streamed(std::this_thread::get_id()));
|
||||
*/
|
||||
template <typename T>
|
||||
constexpr auto streamed(const T& value) -> detail::streamed_view<T> {
|
||||
return {value};
|
||||
}
|
||||
|
||||
namespace detail {
|
||||
|
||||
inline void vprint_directly(std::ostream& os, string_view format_str,
|
||||
format_args args) {
|
||||
auto buffer = memory_buffer();
|
||||
detail::vformat_to(buffer, format_str, args);
|
||||
detail::write_buffer(os, buffer);
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
FMT_EXPORT template <typename Char>
|
||||
void vprint(std::basic_ostream<Char>& os,
|
||||
basic_string_view<type_identity_t<Char>> format_str,
|
||||
typename detail::vformat_args<Char>::type args) {
|
||||
auto buffer = basic_memory_buffer<Char>();
|
||||
detail::vformat_to(buffer, format_str, args);
|
||||
if (detail::write_ostream_unicode(os, {buffer.data(), buffer.size()})) return;
|
||||
detail::write_buffer(os, buffer);
|
||||
}
|
||||
|
||||
/**
|
||||
* Prints formatted data to the stream `os`.
|
||||
*
|
||||
* **Example**:
|
||||
*
|
||||
* fmt::print(cerr, "Don't {}!", "panic");
|
||||
*/
|
||||
FMT_EXPORT template <typename... T>
|
||||
void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
|
||||
const auto& vargs = fmt::make_format_args(args...);
|
||||
if (detail::use_utf8())
|
||||
vprint(os, fmt, vargs);
|
||||
else
|
||||
detail::vprint_directly(os, fmt, vargs);
|
||||
}
|
||||
|
||||
FMT_EXPORT
|
||||
template <typename... Args>
|
||||
void print(std::wostream& os,
|
||||
basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
|
||||
Args&&... args) {
|
||||
vprint(os, fmt, fmt::make_format_args<buffered_context<wchar_t>>(args...));
|
||||
}
|
||||
|
||||
FMT_EXPORT template <typename... T>
|
||||
void println(std::ostream& os, format_string<T...> fmt, T&&... args) {
|
||||
fmt::print(os, "{}\n", fmt::format(fmt, std::forward<T>(args)...));
|
||||
}
|
||||
|
||||
FMT_EXPORT
|
||||
template <typename... Args>
|
||||
void println(std::wostream& os,
|
||||
basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
|
||||
Args&&... args) {
|
||||
print(os, L"{}\n", fmt::format(fmt, std::forward<Args>(args)...));
|
||||
}
|
||||
|
||||
FMT_END_NAMESPACE
|
||||
|
||||
#endif // FMT_OSTREAM_H_
|
||||
|
|
@ -0,0 +1,656 @@
|
|||
// Formatting library for C++ - legacy printf implementation
|
||||
//
|
||||
// Copyright (c) 2012 - 2016, Victor Zverovich
|
||||
// All rights reserved.
|
||||
//
|
||||
// For the license information refer to format.h.
|
||||
|
||||
#ifndef FMT_PRINTF_H_
|
||||
#define FMT_PRINTF_H_
|
||||
|
||||
#ifndef FMT_MODULE
|
||||
# include <algorithm> // std::max
|
||||
# include <limits> // std::numeric_limits
|
||||
#endif
|
||||
|
||||
#include "format.h"
|
||||
|
||||
FMT_BEGIN_NAMESPACE
|
||||
FMT_BEGIN_EXPORT
|
||||
|
||||
template <typename T> struct printf_formatter {
|
||||
printf_formatter() = delete;
|
||||
};
|
||||
|
||||
template <typename Char> class basic_printf_context {
|
||||
private:
|
||||
basic_appender<Char> out_;
|
||||
basic_format_args<basic_printf_context> args_;
|
||||
|
||||
static_assert(std::is_same<Char, char>::value ||
|
||||
std::is_same<Char, wchar_t>::value,
|
||||
"Unsupported code unit type.");
|
||||
|
||||
public:
|
||||
using char_type = Char;
|
||||
using parse_context_type = basic_format_parse_context<Char>;
|
||||
template <typename T> using formatter_type = printf_formatter<T>;
|
||||
|
||||
/// Constructs a `printf_context` object. References to the arguments are
|
||||
/// stored in the context object so make sure they have appropriate lifetimes.
|
||||
basic_printf_context(basic_appender<Char> out,
|
||||
basic_format_args<basic_printf_context> args)
|
||||
: out_(out), args_(args) {}
|
||||
|
||||
auto out() -> basic_appender<Char> { return out_; }
|
||||
void advance_to(basic_appender<Char>) {}
|
||||
|
||||
auto locale() -> detail::locale_ref { return {}; }
|
||||
|
||||
auto arg(int id) const -> basic_format_arg<basic_printf_context> {
|
||||
return args_.get(id);
|
||||
}
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
// Checks if a value fits in int - used to avoid warnings about comparing
|
||||
// signed and unsigned integers.
|
||||
template <bool IsSigned> struct int_checker {
|
||||
template <typename T> static auto fits_in_int(T value) -> bool {
|
||||
unsigned max = to_unsigned(max_value<int>());
|
||||
return value <= max;
|
||||
}
|
||||
static auto fits_in_int(bool) -> bool { return true; }
|
||||
};
|
||||
|
||||
template <> struct int_checker<true> {
|
||||
template <typename T> static auto fits_in_int(T value) -> bool {
|
||||
return value >= (std::numeric_limits<int>::min)() &&
|
||||
value <= max_value<int>();
|
||||
}
|
||||
static auto fits_in_int(int) -> bool { return true; }
|
||||
};
|
||||
|
||||
struct printf_precision_handler {
|
||||
template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
|
||||
auto operator()(T value) -> int {
|
||||
if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
|
||||
report_error("number is too big");
|
||||
return (std::max)(static_cast<int>(value), 0);
|
||||
}
|
||||
|
||||
template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
|
||||
auto operator()(T) -> int {
|
||||
report_error("precision is not integer");
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
|
||||
// An argument visitor that returns true iff arg is a zero integer.
|
||||
struct is_zero_int {
|
||||
template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
|
||||
auto operator()(T value) -> bool {
|
||||
return value == 0;
|
||||
}
|
||||
|
||||
template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
|
||||
auto operator()(T) -> bool {
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};
|
||||
|
||||
template <> struct make_unsigned_or_bool<bool> {
|
||||
using type = bool;
|
||||
};
|
||||
|
||||
template <typename T, typename Context> class arg_converter {
|
||||
private:
|
||||
using char_type = typename Context::char_type;
|
||||
|
||||
basic_format_arg<Context>& arg_;
|
||||
char_type type_;
|
||||
|
||||
public:
|
||||
arg_converter(basic_format_arg<Context>& arg, char_type type)
|
||||
: arg_(arg), type_(type) {}
|
||||
|
||||
void operator()(bool value) {
|
||||
if (type_ != 's') operator()<bool>(value);
|
||||
}
|
||||
|
||||
template <typename U, FMT_ENABLE_IF(std::is_integral<U>::value)>
|
||||
void operator()(U value) {
|
||||
bool is_signed = type_ == 'd' || type_ == 'i';
|
||||
using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
|
||||
if (const_check(sizeof(target_type) <= sizeof(int))) {
|
||||
// Extra casts are used to silence warnings.
|
||||
if (is_signed) {
|
||||
auto n = static_cast<int>(static_cast<target_type>(value));
|
||||
arg_ = detail::make_arg<Context>(n);
|
||||
} else {
|
||||
using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
|
||||
auto n = static_cast<unsigned>(static_cast<unsigned_type>(value));
|
||||
arg_ = detail::make_arg<Context>(n);
|
||||
}
|
||||
} else {
|
||||
if (is_signed) {
|
||||
// glibc's printf doesn't sign extend arguments of smaller types:
|
||||
// std::printf("%lld", -42); // prints "4294967254"
|
||||
// but we don't have to do the same because it's a UB.
|
||||
auto n = static_cast<long long>(value);
|
||||
arg_ = detail::make_arg<Context>(n);
|
||||
} else {
|
||||
auto n = static_cast<typename make_unsigned_or_bool<U>::type>(value);
|
||||
arg_ = detail::make_arg<Context>(n);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template <typename U, FMT_ENABLE_IF(!std::is_integral<U>::value)>
|
||||
void operator()(U) {} // No conversion needed for non-integral types.
|
||||
};
|
||||
|
||||
// Converts an integer argument to T for printf, if T is an integral type.
|
||||
// If T is void, the argument is converted to corresponding signed or unsigned
|
||||
// type depending on the type specifier: 'd' and 'i' - signed, other -
|
||||
// unsigned).
|
||||
template <typename T, typename Context, typename Char>
|
||||
void convert_arg(basic_format_arg<Context>& arg, Char type) {
|
||||
arg.visit(arg_converter<T, Context>(arg, type));
|
||||
}
|
||||
|
||||
// Converts an integer argument to char for printf.
|
||||
template <typename Context> class char_converter {
|
||||
private:
|
||||
basic_format_arg<Context>& arg_;
|
||||
|
||||
public:
|
||||
explicit char_converter(basic_format_arg<Context>& arg) : arg_(arg) {}
|
||||
|
||||
template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
|
||||
void operator()(T value) {
|
||||
auto c = static_cast<typename Context::char_type>(value);
|
||||
arg_ = detail::make_arg<Context>(c);
|
||||
}
|
||||
|
||||
template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
|
||||
void operator()(T) {} // No conversion needed for non-integral types.
|
||||
};
|
||||
|
||||
// An argument visitor that return a pointer to a C string if argument is a
|
||||
// string or null otherwise.
|
||||
template <typename Char> struct get_cstring {
|
||||
template <typename T> auto operator()(T) -> const Char* { return nullptr; }
|
||||
auto operator()(const Char* s) -> const Char* { return s; }
|
||||
};
|
||||
|
||||
// Checks if an argument is a valid printf width specifier and sets
|
||||
// left alignment if it is negative.
|
||||
class printf_width_handler {
|
||||
private:
|
||||
format_specs& specs_;
|
||||
|
||||
public:
|
||||
explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
|
||||
|
||||
template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
|
||||
auto operator()(T value) -> unsigned {
|
||||
auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
|
||||
if (detail::is_negative(value)) {
|
||||
specs_.align = align::left;
|
||||
width = 0 - width;
|
||||
}
|
||||
unsigned int_max = to_unsigned(max_value<int>());
|
||||
if (width > int_max) report_error("number is too big");
|
||||
return static_cast<unsigned>(width);
|
||||
}
|
||||
|
||||
template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
|
||||
auto operator()(T) -> unsigned {
|
||||
report_error("width is not integer");
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
|
||||
// Workaround for a bug with the XL compiler when initializing
|
||||
// printf_arg_formatter's base class.
|
||||
template <typename Char>
|
||||
auto make_arg_formatter(basic_appender<Char> iter, format_specs& s)
|
||||
-> arg_formatter<Char> {
|
||||
return {iter, s, locale_ref()};
|
||||
}
|
||||
|
||||
// The `printf` argument formatter.
|
||||
template <typename Char>
|
||||
class printf_arg_formatter : public arg_formatter<Char> {
|
||||
private:
|
||||
using base = arg_formatter<Char>;
|
||||
using context_type = basic_printf_context<Char>;
|
||||
|
||||
context_type& context_;
|
||||
|
||||
void write_null_pointer(bool is_string = false) {
|
||||
auto s = this->specs;
|
||||
s.type = presentation_type::none;
|
||||
write_bytes<Char>(this->out, is_string ? "(null)" : "(nil)", s);
|
||||
}
|
||||
|
||||
public:
|
||||
printf_arg_formatter(basic_appender<Char> iter, format_specs& s,
|
||||
context_type& ctx)
|
||||
: base(make_arg_formatter(iter, s)), context_(ctx) {}
|
||||
|
||||
void operator()(monostate value) { base::operator()(value); }
|
||||
|
||||
template <typename T, FMT_ENABLE_IF(detail::is_integral<T>::value)>
|
||||
void operator()(T value) {
|
||||
// MSVC2013 fails to compile separate overloads for bool and Char so use
|
||||
// std::is_same instead.
|
||||
if (!std::is_same<T, Char>::value) {
|
||||
base::operator()(value);
|
||||
return;
|
||||
}
|
||||
format_specs s = this->specs;
|
||||
if (s.type != presentation_type::none && s.type != presentation_type::chr) {
|
||||
return (*this)(static_cast<int>(value));
|
||||
}
|
||||
s.sign = sign::none;
|
||||
s.alt = false;
|
||||
s.fill = ' '; // Ignore '0' flag for char types.
|
||||
// align::numeric needs to be overwritten here since the '0' flag is
|
||||
// ignored for non-numeric types
|
||||
if (s.align == align::none || s.align == align::numeric)
|
||||
s.align = align::right;
|
||||
write<Char>(this->out, static_cast<Char>(value), s);
|
||||
}
|
||||
|
||||
template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
|
||||
void operator()(T value) {
|
||||
base::operator()(value);
|
||||
}
|
||||
|
||||
void operator()(const char* value) {
|
||||
if (value)
|
||||
base::operator()(value);
|
||||
else
|
||||
write_null_pointer(this->specs.type != presentation_type::pointer);
|
||||
}
|
||||
|
||||
void operator()(const wchar_t* value) {
|
||||
if (value)
|
||||
base::operator()(value);
|
||||
else
|
||||
write_null_pointer(this->specs.type != presentation_type::pointer);
|
||||
}
|
||||
|
||||
void operator()(basic_string_view<Char> value) { base::operator()(value); }
|
||||
|
||||
void operator()(const void* value) {
|
||||
if (value)
|
||||
base::operator()(value);
|
||||
else
|
||||
write_null_pointer();
|
||||
}
|
||||
|
||||
void operator()(typename basic_format_arg<context_type>::handle handle) {
|
||||
auto parse_ctx = basic_format_parse_context<Char>({});
|
||||
handle.format(parse_ctx, context_);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Char>
|
||||
void parse_flags(format_specs& specs, const Char*& it, const Char* end) {
|
||||
for (; it != end; ++it) {
|
||||
switch (*it) {
|
||||
case '-':
|
||||
specs.align = align::left;
|
||||
break;
|
||||
case '+':
|
||||
specs.sign = sign::plus;
|
||||
break;
|
||||
case '0':
|
||||
specs.fill = '0';
|
||||
break;
|
||||
case ' ':
|
||||
if (specs.sign != sign::plus) specs.sign = sign::space;
|
||||
break;
|
||||
case '#':
|
||||
specs.alt = true;
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template <typename Char, typename GetArg>
|
||||
auto parse_header(const Char*& it, const Char* end, format_specs& specs,
|
||||
GetArg get_arg) -> int {
|
||||
int arg_index = -1;
|
||||
Char c = *it;
|
||||
if (c >= '0' && c <= '9') {
|
||||
// Parse an argument index (if followed by '$') or a width possibly
|
||||
// preceded with '0' flag(s).
|
||||
int value = parse_nonnegative_int(it, end, -1);
|
||||
if (it != end && *it == '$') { // value is an argument index
|
||||
++it;
|
||||
arg_index = value != -1 ? value : max_value<int>();
|
||||
} else {
|
||||
if (c == '0') specs.fill = '0';
|
||||
if (value != 0) {
|
||||
// Nonzero value means that we parsed width and don't need to
|
||||
// parse it or flags again, so return now.
|
||||
if (value == -1) report_error("number is too big");
|
||||
specs.width = value;
|
||||
return arg_index;
|
||||
}
|
||||
}
|
||||
}
|
||||
parse_flags(specs, it, end);
|
||||
// Parse width.
|
||||
if (it != end) {
|
||||
if (*it >= '0' && *it <= '9') {
|
||||
specs.width = parse_nonnegative_int(it, end, -1);
|
||||
if (specs.width == -1) report_error("number is too big");
|
||||
} else if (*it == '*') {
|
||||
++it;
|
||||
specs.width = static_cast<int>(
|
||||
get_arg(-1).visit(detail::printf_width_handler(specs)));
|
||||
}
|
||||
}
|
||||
return arg_index;
|
||||
}
|
||||
|
||||
inline auto parse_printf_presentation_type(char c, type t, bool& upper)
|
||||
-> presentation_type {
|
||||
using pt = presentation_type;
|
||||
constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
|
||||
switch (c) {
|
||||
case 'd':
|
||||
return in(t, integral_set) ? pt::dec : pt::none;
|
||||
case 'o':
|
||||
return in(t, integral_set) ? pt::oct : pt::none;
|
||||
case 'X':
|
||||
upper = true;
|
||||
FMT_FALLTHROUGH;
|
||||
case 'x':
|
||||
return in(t, integral_set) ? pt::hex : pt::none;
|
||||
case 'E':
|
||||
upper = true;
|
||||
FMT_FALLTHROUGH;
|
||||
case 'e':
|
||||
return in(t, float_set) ? pt::exp : pt::none;
|
||||
case 'F':
|
||||
upper = true;
|
||||
FMT_FALLTHROUGH;
|
||||
case 'f':
|
||||
return in(t, float_set) ? pt::fixed : pt::none;
|
||||
case 'G':
|
||||
upper = true;
|
||||
FMT_FALLTHROUGH;
|
||||
case 'g':
|
||||
return in(t, float_set) ? pt::general : pt::none;
|
||||
case 'A':
|
||||
upper = true;
|
||||
FMT_FALLTHROUGH;
|
||||
case 'a':
|
||||
return in(t, float_set) ? pt::hexfloat : pt::none;
|
||||
case 'c':
|
||||
return in(t, integral_set) ? pt::chr : pt::none;
|
||||
case 's':
|
||||
return in(t, string_set | cstring_set) ? pt::string : pt::none;
|
||||
case 'p':
|
||||
return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none;
|
||||
default:
|
||||
return pt::none;
|
||||
}
|
||||
}
|
||||
|
||||
template <typename Char, typename Context>
|
||||
void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
|
||||
basic_format_args<Context> args) {
|
||||
using iterator = basic_appender<Char>;
|
||||
auto out = iterator(buf);
|
||||
auto context = basic_printf_context<Char>(out, args);
|
||||
auto parse_ctx = basic_format_parse_context<Char>(format);
|
||||
|
||||
// Returns the argument with specified index or, if arg_index is -1, the next
|
||||
// argument.
|
||||
auto get_arg = [&](int arg_index) {
|
||||
if (arg_index < 0)
|
||||
arg_index = parse_ctx.next_arg_id();
|
||||
else
|
||||
parse_ctx.check_arg_id(--arg_index);
|
||||
return detail::get_arg(context, arg_index);
|
||||
};
|
||||
|
||||
const Char* start = parse_ctx.begin();
|
||||
const Char* end = parse_ctx.end();
|
||||
auto it = start;
|
||||
while (it != end) {
|
||||
if (!find<false, Char>(it, end, '%', it)) {
|
||||
it = end; // find leaves it == nullptr if it doesn't find '%'.
|
||||
break;
|
||||
}
|
||||
Char c = *it++;
|
||||
if (it != end && *it == c) {
|
||||
write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
|
||||
start = ++it;
|
||||
continue;
|
||||
}
|
||||
write(out, basic_string_view<Char>(start, to_unsigned(it - 1 - start)));
|
||||
|
||||
auto specs = format_specs();
|
||||
specs.align = align::right;
|
||||
|
||||
// Parse argument index, flags and width.
|
||||
int arg_index = parse_header(it, end, specs, get_arg);
|
||||
if (arg_index == 0) report_error("argument not found");
|
||||
|
||||
// Parse precision.
|
||||
if (it != end && *it == '.') {
|
||||
++it;
|
||||
c = it != end ? *it : 0;
|
||||
if ('0' <= c && c <= '9') {
|
||||
specs.precision = parse_nonnegative_int(it, end, 0);
|
||||
} else if (c == '*') {
|
||||
++it;
|
||||
specs.precision =
|
||||
static_cast<int>(get_arg(-1).visit(printf_precision_handler()));
|
||||
} else {
|
||||
specs.precision = 0;
|
||||
}
|
||||
}
|
||||
|
||||
auto arg = get_arg(arg_index);
|
||||
// For d, i, o, u, x, and X conversion specifiers, if a precision is
|
||||
// specified, the '0' flag is ignored
|
||||
if (specs.precision >= 0 && arg.is_integral()) {
|
||||
// Ignore '0' for non-numeric types or if '-' present.
|
||||
specs.fill = ' ';
|
||||
}
|
||||
if (specs.precision >= 0 && arg.type() == type::cstring_type) {
|
||||
auto str = arg.visit(get_cstring<Char>());
|
||||
auto str_end = str + specs.precision;
|
||||
auto nul = std::find(str, str_end, Char());
|
||||
auto sv = basic_string_view<Char>(
|
||||
str, to_unsigned(nul != str_end ? nul - str : specs.precision));
|
||||
arg = make_arg<basic_printf_context<Char>>(sv);
|
||||
}
|
||||
if (specs.alt && arg.visit(is_zero_int())) specs.alt = false;
|
||||
if (specs.fill.template get<Char>() == '0') {
|
||||
if (arg.is_arithmetic() && specs.align != align::left)
|
||||
specs.align = align::numeric;
|
||||
else
|
||||
specs.fill = ' '; // Ignore '0' flag for non-numeric types or if '-'
|
||||
// flag is also present.
|
||||
}
|
||||
|
||||
// Parse length and convert the argument to the required type.
|
||||
c = it != end ? *it++ : 0;
|
||||
Char t = it != end ? *it : 0;
|
||||
switch (c) {
|
||||
case 'h':
|
||||
if (t == 'h') {
|
||||
++it;
|
||||
t = it != end ? *it : 0;
|
||||
convert_arg<signed char>(arg, t);
|
||||
} else {
|
||||
convert_arg<short>(arg, t);
|
||||
}
|
||||
break;
|
||||
case 'l':
|
||||
if (t == 'l') {
|
||||
++it;
|
||||
t = it != end ? *it : 0;
|
||||
convert_arg<long long>(arg, t);
|
||||
} else {
|
||||
convert_arg<long>(arg, t);
|
||||
}
|
||||
break;
|
||||
case 'j':
|
||||
convert_arg<intmax_t>(arg, t);
|
||||
break;
|
||||
case 'z':
|
||||
convert_arg<size_t>(arg, t);
|
||||
break;
|
||||
case 't':
|
||||
convert_arg<std::ptrdiff_t>(arg, t);
|
||||
break;
|
||||
case 'L':
|
||||
// printf produces garbage when 'L' is omitted for long double, no
|
||||
// need to do the same.
|
||||
break;
|
||||
default:
|
||||
--it;
|
||||
convert_arg<void>(arg, c);
|
||||
}
|
||||
|
||||
// Parse type.
|
||||
if (it == end) report_error("invalid format string");
|
||||
char type = static_cast<char>(*it++);
|
||||
if (arg.is_integral()) {
|
||||
// Normalize type.
|
||||
switch (type) {
|
||||
case 'i':
|
||||
case 'u':
|
||||
type = 'd';
|
||||
break;
|
||||
case 'c':
|
||||
arg.visit(char_converter<basic_printf_context<Char>>(arg));
|
||||
break;
|
||||
}
|
||||
}
|
||||
bool upper = false;
|
||||
specs.type = parse_printf_presentation_type(type, arg.type(), upper);
|
||||
if (specs.type == presentation_type::none)
|
||||
report_error("invalid format specifier");
|
||||
specs.upper = upper;
|
||||
|
||||
start = it;
|
||||
|
||||
// Format argument.
|
||||
arg.visit(printf_arg_formatter<Char>(out, specs, context));
|
||||
}
|
||||
write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
|
||||
}
|
||||
} // namespace detail
|
||||
|
||||
using printf_context = basic_printf_context<char>;
|
||||
using wprintf_context = basic_printf_context<wchar_t>;
|
||||
|
||||
using printf_args = basic_format_args<printf_context>;
|
||||
using wprintf_args = basic_format_args<wprintf_context>;
|
||||
|
||||
/// Constructs an `format_arg_store` object that contains references to
|
||||
/// arguments and can be implicitly converted to `printf_args`.
|
||||
template <typename Char = char, typename... T>
|
||||
inline auto make_printf_args(T&... args)
|
||||
-> decltype(fmt::make_format_args<basic_printf_context<Char>>(args...)) {
|
||||
return fmt::make_format_args<basic_printf_context<Char>>(args...);
|
||||
}
|
||||
|
||||
template <typename Char> struct vprintf_args {
|
||||
using type = basic_format_args<basic_printf_context<Char>>;
|
||||
};
|
||||
|
||||
template <typename Char>
|
||||
inline auto vsprintf(basic_string_view<Char> fmt,
|
||||
typename vprintf_args<Char>::type args)
|
||||
-> std::basic_string<Char> {
|
||||
auto buf = basic_memory_buffer<Char>();
|
||||
detail::vprintf(buf, fmt, args);
|
||||
return to_string(buf);
|
||||
}
|
||||
|
||||
/**
|
||||
* Formats `args` according to specifications in `fmt` and returns the result
|
||||
* as as string.
|
||||
*
|
||||
* **Example**:
|
||||
*
|
||||
* std::string message = fmt::sprintf("The answer is %d", 42);
|
||||
*/
|
||||
template <typename S, typename... T, typename Char = char_t<S>>
|
||||
inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> {
|
||||
return vsprintf(detail::to_string_view(fmt),
|
||||
fmt::make_format_args<basic_printf_context<Char>>(args...));
|
||||
}
|
||||
|
||||
template <typename Char>
|
||||
inline auto vfprintf(std::FILE* f, basic_string_view<Char> fmt,
|
||||
typename vprintf_args<Char>::type args) -> int {
|
||||
auto buf = basic_memory_buffer<Char>();
|
||||
detail::vprintf(buf, fmt, args);
|
||||
size_t size = buf.size();
|
||||
return std::fwrite(buf.data(), sizeof(Char), size, f) < size
|
||||
? -1
|
||||
: static_cast<int>(size);
|
||||
}
|
||||
|
||||
/**
|
||||
* Formats `args` according to specifications in `fmt` and writes the output
|
||||
* to `f`.
|
||||
*
|
||||
* **Example**:
|
||||
*
|
||||
* fmt::fprintf(stderr, "Don't %s!", "panic");
|
||||
*/
|
||||
template <typename S, typename... T, typename Char = char_t<S>>
|
||||
inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int {
|
||||
return vfprintf(f, detail::to_string_view(fmt),
|
||||
make_printf_args<Char>(args...));
|
||||
}
|
||||
|
||||
template <typename Char>
|
||||
FMT_DEPRECATED inline auto vprintf(basic_string_view<Char> fmt,
|
||||
typename vprintf_args<Char>::type args)
|
||||
-> int {
|
||||
return vfprintf(stdout, fmt, args);
|
||||
}
|
||||
|
||||
/**
|
||||
* Formats `args` according to specifications in `fmt` and writes the output
|
||||
* to `stdout`.
|
||||
*
|
||||
* **Example**:
|
||||
*
|
||||
* fmt::printf("Elapsed time: %.2f seconds", 1.23);
|
||||
*/
|
||||
template <typename... T>
|
||||
inline auto printf(string_view fmt, const T&... args) -> int {
|
||||
return vfprintf(stdout, fmt, make_printf_args(args...));
|
||||
}
|
||||
template <typename... T>
|
||||
FMT_DEPRECATED inline auto printf(basic_string_view<wchar_t> fmt,
|
||||
const T&... args) -> int {
|
||||
return vfprintf(stdout, fmt, make_printf_args<wchar_t>(args...));
|
||||
}
|
||||
|
||||
FMT_END_EXPORT
|
||||
FMT_END_NAMESPACE
|
||||
|
||||
#endif // FMT_PRINTF_H_
|
||||
|
|
@ -0,0 +1,882 @@
|
|||
// Formatting library for C++ - range and tuple support
|
||||
//
|
||||
// Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors
|
||||
// All rights reserved.
|
||||
//
|
||||
// For the license information refer to format.h.
|
||||
|
||||
#ifndef FMT_RANGES_H_
|
||||
#define FMT_RANGES_H_
|
||||
|
||||
#ifndef FMT_MODULE
|
||||
# include <initializer_list>
|
||||
# include <iterator>
|
||||
# include <string>
|
||||
# include <tuple>
|
||||
# include <type_traits>
|
||||
# include <utility>
|
||||
#endif
|
||||
|
||||
#include "format.h"
|
||||
|
||||
FMT_BEGIN_NAMESPACE
|
||||
|
||||
FMT_EXPORT
|
||||
enum class range_format { disabled, map, set, sequence, string, debug_string };
|
||||
|
||||
namespace detail {
|
||||
|
||||
template <typename T> class is_map {
|
||||
template <typename U> static auto check(U*) -> typename U::mapped_type;
|
||||
template <typename> static void check(...);
|
||||
|
||||
public:
|
||||
static constexpr const bool value =
|
||||
!std::is_void<decltype(check<T>(nullptr))>::value;
|
||||
};
|
||||
|
||||
template <typename T> class is_set {
|
||||
template <typename U> static auto check(U*) -> typename U::key_type;
|
||||
template <typename> static void check(...);
|
||||
|
||||
public:
|
||||
static constexpr const bool value =
|
||||
!std::is_void<decltype(check<T>(nullptr))>::value && !is_map<T>::value;
|
||||
};
|
||||
|
||||
template <typename... Ts> struct conditional_helper {};
|
||||
|
||||
template <typename T, typename _ = void> struct is_range_ : std::false_type {};
|
||||
|
||||
#if !FMT_MSC_VERSION || FMT_MSC_VERSION > 1800
|
||||
|
||||
# define FMT_DECLTYPE_RETURN(val) \
|
||||
->decltype(val) { return val; } \
|
||||
static_assert( \
|
||||
true, "") // This makes it so that a semicolon is required after the
|
||||
// macro, which helps clang-format handle the formatting.
|
||||
|
||||
// C array overload
|
||||
template <typename T, std::size_t N>
|
||||
auto range_begin(const T (&arr)[N]) -> const T* {
|
||||
return arr;
|
||||
}
|
||||
template <typename T, std::size_t N>
|
||||
auto range_end(const T (&arr)[N]) -> const T* {
|
||||
return arr + N;
|
||||
}
|
||||
|
||||
template <typename T, typename Enable = void>
|
||||
struct has_member_fn_begin_end_t : std::false_type {};
|
||||
|
||||
template <typename T>
|
||||
struct has_member_fn_begin_end_t<T, void_t<decltype(*std::declval<T>().begin()),
|
||||
decltype(std::declval<T>().end())>>
|
||||
: std::true_type {};
|
||||
|
||||
// Member function overloads.
|
||||
template <typename T>
|
||||
auto range_begin(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).begin());
|
||||
template <typename T>
|
||||
auto range_end(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).end());
|
||||
|
||||
// ADL overloads. Only participate in overload resolution if member functions
|
||||
// are not found.
|
||||
template <typename T>
|
||||
auto range_begin(T&& rng)
|
||||
-> enable_if_t<!has_member_fn_begin_end_t<T&&>::value,
|
||||
decltype(begin(static_cast<T&&>(rng)))> {
|
||||
return begin(static_cast<T&&>(rng));
|
||||
}
|
||||
template <typename T>
|
||||
auto range_end(T&& rng) -> enable_if_t<!has_member_fn_begin_end_t<T&&>::value,
|
||||
decltype(end(static_cast<T&&>(rng)))> {
|
||||
return end(static_cast<T&&>(rng));
|
||||
}
|
||||
|
||||
template <typename T, typename Enable = void>
|
||||
struct has_const_begin_end : std::false_type {};
|
||||
template <typename T, typename Enable = void>
|
||||
struct has_mutable_begin_end : std::false_type {};
|
||||
|
||||
template <typename T>
|
||||
struct has_const_begin_end<
|
||||
T, void_t<decltype(*detail::range_begin(
|
||||
std::declval<const remove_cvref_t<T>&>())),
|
||||
decltype(detail::range_end(
|
||||
std::declval<const remove_cvref_t<T>&>()))>>
|
||||
: std::true_type {};
|
||||
|
||||
template <typename T>
|
||||
struct has_mutable_begin_end<
|
||||
T, void_t<decltype(*detail::range_begin(std::declval<T&>())),
|
||||
decltype(detail::range_end(std::declval<T&>())),
|
||||
// the extra int here is because older versions of MSVC don't
|
||||
// SFINAE properly unless there are distinct types
|
||||
int>> : std::true_type {};
|
||||
|
||||
template <typename T>
|
||||
struct is_range_<T, void>
|
||||
: std::integral_constant<bool, (has_const_begin_end<T>::value ||
|
||||
has_mutable_begin_end<T>::value)> {};
|
||||
# undef FMT_DECLTYPE_RETURN
|
||||
#endif
|
||||
|
||||
// tuple_size and tuple_element check.
|
||||
template <typename T> class is_tuple_like_ {
|
||||
template <typename U>
|
||||
static auto check(U* p) -> decltype(std::tuple_size<U>::value, int());
|
||||
template <typename> static void check(...);
|
||||
|
||||
public:
|
||||
static constexpr const bool value =
|
||||
!std::is_void<decltype(check<T>(nullptr))>::value;
|
||||
};
|
||||
|
||||
// Check for integer_sequence
|
||||
#if defined(__cpp_lib_integer_sequence) || FMT_MSC_VERSION >= 1900
|
||||
template <typename T, T... N>
|
||||
using integer_sequence = std::integer_sequence<T, N...>;
|
||||
template <size_t... N> using index_sequence = std::index_sequence<N...>;
|
||||
template <size_t N> using make_index_sequence = std::make_index_sequence<N>;
|
||||
#else
|
||||
template <typename T, T... N> struct integer_sequence {
|
||||
using value_type = T;
|
||||
|
||||
static FMT_CONSTEXPR auto size() -> size_t { return sizeof...(N); }
|
||||
};
|
||||
|
||||
template <size_t... N> using index_sequence = integer_sequence<size_t, N...>;
|
||||
|
||||
template <typename T, size_t N, T... Ns>
|
||||
struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...> {};
|
||||
template <typename T, T... Ns>
|
||||
struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...> {};
|
||||
|
||||
template <size_t N>
|
||||
using make_index_sequence = make_integer_sequence<size_t, N>;
|
||||
#endif
|
||||
|
||||
template <typename T>
|
||||
using tuple_index_sequence = make_index_sequence<std::tuple_size<T>::value>;
|
||||
|
||||
template <typename T, typename C, bool = is_tuple_like_<T>::value>
|
||||
class is_tuple_formattable_ {
|
||||
public:
|
||||
static constexpr const bool value = false;
|
||||
};
|
||||
template <typename T, typename C> class is_tuple_formattable_<T, C, true> {
|
||||
template <size_t... Is>
|
||||
static auto all_true(index_sequence<Is...>,
|
||||
integer_sequence<bool, (Is >= 0)...>) -> std::true_type;
|
||||
static auto all_true(...) -> std::false_type;
|
||||
|
||||
template <size_t... Is>
|
||||
static auto check(index_sequence<Is...>) -> decltype(all_true(
|
||||
index_sequence<Is...>{},
|
||||
integer_sequence<bool,
|
||||
(is_formattable<typename std::tuple_element<Is, T>::type,
|
||||
C>::value)...>{}));
|
||||
|
||||
public:
|
||||
static constexpr const bool value =
|
||||
decltype(check(tuple_index_sequence<T>{}))::value;
|
||||
};
|
||||
|
||||
template <typename Tuple, typename F, size_t... Is>
|
||||
FMT_CONSTEXPR void for_each(index_sequence<Is...>, Tuple&& t, F&& f) {
|
||||
using std::get;
|
||||
// Using a free function get<Is>(Tuple) now.
|
||||
const int unused[] = {0, ((void)f(get<Is>(t)), 0)...};
|
||||
ignore_unused(unused);
|
||||
}
|
||||
|
||||
template <typename Tuple, typename F>
|
||||
FMT_CONSTEXPR void for_each(Tuple&& t, F&& f) {
|
||||
for_each(tuple_index_sequence<remove_cvref_t<Tuple>>(),
|
||||
std::forward<Tuple>(t), std::forward<F>(f));
|
||||
}
|
||||
|
||||
template <typename Tuple1, typename Tuple2, typename F, size_t... Is>
|
||||
void for_each2(index_sequence<Is...>, Tuple1&& t1, Tuple2&& t2, F&& f) {
|
||||
using std::get;
|
||||
const int unused[] = {0, ((void)f(get<Is>(t1), get<Is>(t2)), 0)...};
|
||||
ignore_unused(unused);
|
||||
}
|
||||
|
||||
template <typename Tuple1, typename Tuple2, typename F>
|
||||
void for_each2(Tuple1&& t1, Tuple2&& t2, F&& f) {
|
||||
for_each2(tuple_index_sequence<remove_cvref_t<Tuple1>>(),
|
||||
std::forward<Tuple1>(t1), std::forward<Tuple2>(t2),
|
||||
std::forward<F>(f));
|
||||
}
|
||||
|
||||
namespace tuple {
|
||||
// Workaround a bug in MSVC 2019 (v140).
|
||||
template <typename Char, typename... T>
|
||||
using result_t = std::tuple<formatter<remove_cvref_t<T>, Char>...>;
|
||||
|
||||
using std::get;
|
||||
template <typename Tuple, typename Char, std::size_t... Is>
|
||||
auto get_formatters(index_sequence<Is...>)
|
||||
-> result_t<Char, decltype(get<Is>(std::declval<Tuple>()))...>;
|
||||
} // namespace tuple
|
||||
|
||||
#if FMT_MSC_VERSION && FMT_MSC_VERSION < 1920
|
||||
// Older MSVC doesn't get the reference type correctly for arrays.
|
||||
template <typename R> struct range_reference_type_impl {
|
||||
using type = decltype(*detail::range_begin(std::declval<R&>()));
|
||||
};
|
||||
|
||||
template <typename T, std::size_t N> struct range_reference_type_impl<T[N]> {
|
||||
using type = T&;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
using range_reference_type = typename range_reference_type_impl<T>::type;
|
||||
#else
|
||||
template <typename Range>
|
||||
using range_reference_type =
|
||||
decltype(*detail::range_begin(std::declval<Range&>()));
|
||||
#endif
|
||||
|
||||
// We don't use the Range's value_type for anything, but we do need the Range's
|
||||
// reference type, with cv-ref stripped.
|
||||
template <typename Range>
|
||||
using uncvref_type = remove_cvref_t<range_reference_type<Range>>;
|
||||
|
||||
template <typename Formatter>
|
||||
FMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set)
|
||||
-> decltype(f.set_debug_format(set)) {
|
||||
f.set_debug_format(set);
|
||||
}
|
||||
template <typename Formatter>
|
||||
FMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {}
|
||||
|
||||
template <typename T>
|
||||
struct range_format_kind_
|
||||
: std::integral_constant<range_format,
|
||||
std::is_same<uncvref_type<T>, T>::value
|
||||
? range_format::disabled
|
||||
: is_map<T>::value ? range_format::map
|
||||
: is_set<T>::value ? range_format::set
|
||||
: range_format::sequence> {};
|
||||
|
||||
template <range_format K>
|
||||
using range_format_constant = std::integral_constant<range_format, K>;
|
||||
|
||||
// These are not generic lambdas for compatibility with C++11.
|
||||
template <typename ParseContext> struct parse_empty_specs {
|
||||
template <typename Formatter> FMT_CONSTEXPR void operator()(Formatter& f) {
|
||||
f.parse(ctx);
|
||||
detail::maybe_set_debug_format(f, true);
|
||||
}
|
||||
ParseContext& ctx;
|
||||
};
|
||||
template <typename FormatContext> struct format_tuple_element {
|
||||
using char_type = typename FormatContext::char_type;
|
||||
|
||||
template <typename T>
|
||||
void operator()(const formatter<T, char_type>& f, const T& v) {
|
||||
if (i > 0) ctx.advance_to(detail::copy<char_type>(separator, ctx.out()));
|
||||
ctx.advance_to(f.format(v, ctx));
|
||||
++i;
|
||||
}
|
||||
|
||||
int i;
|
||||
FormatContext& ctx;
|
||||
basic_string_view<char_type> separator;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template <typename T> struct is_tuple_like {
|
||||
static constexpr const bool value =
|
||||
detail::is_tuple_like_<T>::value && !detail::is_range_<T>::value;
|
||||
};
|
||||
|
||||
template <typename T, typename C> struct is_tuple_formattable {
|
||||
static constexpr const bool value =
|
||||
detail::is_tuple_formattable_<T, C>::value;
|
||||
};
|
||||
|
||||
template <typename Tuple, typename Char>
|
||||
struct formatter<Tuple, Char,
|
||||
enable_if_t<fmt::is_tuple_like<Tuple>::value &&
|
||||
fmt::is_tuple_formattable<Tuple, Char>::value>> {
|
||||
private:
|
||||
decltype(detail::tuple::get_formatters<Tuple, Char>(
|
||||
detail::tuple_index_sequence<Tuple>())) formatters_;
|
||||
|
||||
basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{};
|
||||
basic_string_view<Char> opening_bracket_ =
|
||||
detail::string_literal<Char, '('>{};
|
||||
basic_string_view<Char> closing_bracket_ =
|
||||
detail::string_literal<Char, ')'>{};
|
||||
|
||||
public:
|
||||
FMT_CONSTEXPR formatter() {}
|
||||
|
||||
FMT_CONSTEXPR void set_separator(basic_string_view<Char> sep) {
|
||||
separator_ = sep;
|
||||
}
|
||||
|
||||
FMT_CONSTEXPR void set_brackets(basic_string_view<Char> open,
|
||||
basic_string_view<Char> close) {
|
||||
opening_bracket_ = open;
|
||||
closing_bracket_ = close;
|
||||
}
|
||||
|
||||
template <typename ParseContext>
|
||||
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
|
||||
auto it = ctx.begin();
|
||||
if (it != ctx.end() && *it != '}') report_error("invalid format specifier");
|
||||
detail::for_each(formatters_, detail::parse_empty_specs<ParseContext>{ctx});
|
||||
return it;
|
||||
}
|
||||
|
||||
template <typename FormatContext>
|
||||
auto format(const Tuple& value, FormatContext& ctx) const
|
||||
-> decltype(ctx.out()) {
|
||||
ctx.advance_to(detail::copy<Char>(opening_bracket_, ctx.out()));
|
||||
detail::for_each2(
|
||||
formatters_, value,
|
||||
detail::format_tuple_element<FormatContext>{0, ctx, separator_});
|
||||
return detail::copy<Char>(closing_bracket_, ctx.out());
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T, typename Char> struct is_range {
|
||||
static constexpr const bool value =
|
||||
detail::is_range_<T>::value && !detail::has_to_string_view<T>::value;
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
template <typename Context> struct range_mapper {
|
||||
using mapper = arg_mapper<Context>;
|
||||
|
||||
template <typename T,
|
||||
FMT_ENABLE_IF(has_formatter<remove_cvref_t<T>, Context>::value)>
|
||||
static auto map(T&& value) -> T&& {
|
||||
return static_cast<T&&>(value);
|
||||
}
|
||||
template <typename T,
|
||||
FMT_ENABLE_IF(!has_formatter<remove_cvref_t<T>, Context>::value)>
|
||||
static auto map(T&& value)
|
||||
-> decltype(mapper().map(static_cast<T&&>(value))) {
|
||||
return mapper().map(static_cast<T&&>(value));
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Char, typename Element>
|
||||
using range_formatter_type =
|
||||
formatter<remove_cvref_t<decltype(range_mapper<buffered_context<Char>>{}
|
||||
.map(std::declval<Element>()))>,
|
||||
Char>;
|
||||
|
||||
template <typename R>
|
||||
using maybe_const_range =
|
||||
conditional_t<has_const_begin_end<R>::value, const R, R>;
|
||||
|
||||
// Workaround a bug in MSVC 2015 and earlier.
|
||||
#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
|
||||
template <typename R, typename Char>
|
||||
struct is_formattable_delayed
|
||||
: is_formattable<uncvref_type<maybe_const_range<R>>, Char> {};
|
||||
#endif
|
||||
} // namespace detail
|
||||
|
||||
template <typename...> struct conjunction : std::true_type {};
|
||||
template <typename P> struct conjunction<P> : P {};
|
||||
template <typename P1, typename... Pn>
|
||||
struct conjunction<P1, Pn...>
|
||||
: conditional_t<bool(P1::value), conjunction<Pn...>, P1> {};
|
||||
|
||||
template <typename T, typename Char, typename Enable = void>
|
||||
struct range_formatter;
|
||||
|
||||
template <typename T, typename Char>
|
||||
struct range_formatter<
|
||||
T, Char,
|
||||
enable_if_t<conjunction<std::is_same<T, remove_cvref_t<T>>,
|
||||
is_formattable<T, Char>>::value>> {
|
||||
private:
|
||||
detail::range_formatter_type<Char, T> underlying_;
|
||||
basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{};
|
||||
basic_string_view<Char> opening_bracket_ =
|
||||
detail::string_literal<Char, '['>{};
|
||||
basic_string_view<Char> closing_bracket_ =
|
||||
detail::string_literal<Char, ']'>{};
|
||||
bool is_debug = false;
|
||||
|
||||
template <typename Output, typename It, typename Sentinel, typename U = T,
|
||||
FMT_ENABLE_IF(std::is_same<U, Char>::value)>
|
||||
auto write_debug_string(Output& out, It it, Sentinel end) const -> Output {
|
||||
auto buf = basic_memory_buffer<Char>();
|
||||
for (; it != end; ++it) buf.push_back(*it);
|
||||
auto specs = format_specs();
|
||||
specs.type = presentation_type::debug;
|
||||
return detail::write<Char>(
|
||||
out, basic_string_view<Char>(buf.data(), buf.size()), specs);
|
||||
}
|
||||
|
||||
template <typename Output, typename It, typename Sentinel, typename U = T,
|
||||
FMT_ENABLE_IF(!std::is_same<U, Char>::value)>
|
||||
auto write_debug_string(Output& out, It, Sentinel) const -> Output {
|
||||
return out;
|
||||
}
|
||||
|
||||
public:
|
||||
FMT_CONSTEXPR range_formatter() {}
|
||||
|
||||
FMT_CONSTEXPR auto underlying() -> detail::range_formatter_type<Char, T>& {
|
||||
return underlying_;
|
||||
}
|
||||
|
||||
FMT_CONSTEXPR void set_separator(basic_string_view<Char> sep) {
|
||||
separator_ = sep;
|
||||
}
|
||||
|
||||
FMT_CONSTEXPR void set_brackets(basic_string_view<Char> open,
|
||||
basic_string_view<Char> close) {
|
||||
opening_bracket_ = open;
|
||||
closing_bracket_ = close;
|
||||
}
|
||||
|
||||
template <typename ParseContext>
|
||||
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
|
||||
auto it = ctx.begin();
|
||||
auto end = ctx.end();
|
||||
detail::maybe_set_debug_format(underlying_, true);
|
||||
if (it == end) return underlying_.parse(ctx);
|
||||
|
||||
switch (detail::to_ascii(*it)) {
|
||||
case 'n':
|
||||
set_brackets({}, {});
|
||||
++it;
|
||||
break;
|
||||
case '?':
|
||||
is_debug = true;
|
||||
set_brackets({}, {});
|
||||
++it;
|
||||
if (it == end || *it != 's') report_error("invalid format specifier");
|
||||
FMT_FALLTHROUGH;
|
||||
case 's':
|
||||
if (!std::is_same<T, Char>::value)
|
||||
report_error("invalid format specifier");
|
||||
if (!is_debug) {
|
||||
set_brackets(detail::string_literal<Char, '"'>{},
|
||||
detail::string_literal<Char, '"'>{});
|
||||
set_separator({});
|
||||
detail::maybe_set_debug_format(underlying_, false);
|
||||
}
|
||||
++it;
|
||||
return it;
|
||||
}
|
||||
|
||||
if (it != end && *it != '}') {
|
||||
if (*it != ':') report_error("invalid format specifier");
|
||||
detail::maybe_set_debug_format(underlying_, false);
|
||||
++it;
|
||||
}
|
||||
|
||||
ctx.advance_to(it);
|
||||
return underlying_.parse(ctx);
|
||||
}
|
||||
|
||||
template <typename R, typename FormatContext>
|
||||
auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) {
|
||||
auto mapper = detail::range_mapper<buffered_context<Char>>();
|
||||
auto out = ctx.out();
|
||||
auto it = detail::range_begin(range);
|
||||
auto end = detail::range_end(range);
|
||||
if (is_debug) return write_debug_string(out, std::move(it), end);
|
||||
|
||||
out = detail::copy<Char>(opening_bracket_, out);
|
||||
int i = 0;
|
||||
for (; it != end; ++it) {
|
||||
if (i > 0) out = detail::copy<Char>(separator_, out);
|
||||
ctx.advance_to(out);
|
||||
auto&& item = *it; // Need an lvalue
|
||||
out = underlying_.format(mapper.map(item), ctx);
|
||||
++i;
|
||||
}
|
||||
out = detail::copy<Char>(closing_bracket_, out);
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
FMT_EXPORT
|
||||
template <typename T, typename Char, typename Enable = void>
|
||||
struct range_format_kind
|
||||
: conditional_t<
|
||||
is_range<T, Char>::value, detail::range_format_kind_<T>,
|
||||
std::integral_constant<range_format, range_format::disabled>> {};
|
||||
|
||||
template <typename R, typename Char>
|
||||
struct formatter<
|
||||
R, Char,
|
||||
enable_if_t<conjunction<
|
||||
bool_constant<
|
||||
range_format_kind<R, Char>::value != range_format::disabled &&
|
||||
range_format_kind<R, Char>::value != range_format::map &&
|
||||
range_format_kind<R, Char>::value != range_format::string &&
|
||||
range_format_kind<R, Char>::value != range_format::debug_string>
|
||||
// Workaround a bug in MSVC 2015 and earlier.
|
||||
#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
|
||||
,
|
||||
detail::is_formattable_delayed<R, Char>
|
||||
#endif
|
||||
>::value>> {
|
||||
private:
|
||||
using range_type = detail::maybe_const_range<R>;
|
||||
range_formatter<detail::uncvref_type<range_type>, Char> range_formatter_;
|
||||
|
||||
public:
|
||||
using nonlocking = void;
|
||||
|
||||
FMT_CONSTEXPR formatter() {
|
||||
if (detail::const_check(range_format_kind<R, Char>::value !=
|
||||
range_format::set))
|
||||
return;
|
||||
range_formatter_.set_brackets(detail::string_literal<Char, '{'>{},
|
||||
detail::string_literal<Char, '}'>{});
|
||||
}
|
||||
|
||||
template <typename ParseContext>
|
||||
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
|
||||
return range_formatter_.parse(ctx);
|
||||
}
|
||||
|
||||
template <typename FormatContext>
|
||||
auto format(range_type& range, FormatContext& ctx) const
|
||||
-> decltype(ctx.out()) {
|
||||
return range_formatter_.format(range, ctx);
|
||||
}
|
||||
};
|
||||
|
||||
// A map formatter.
|
||||
template <typename R, typename Char>
|
||||
struct formatter<
|
||||
R, Char,
|
||||
enable_if_t<range_format_kind<R, Char>::value == range_format::map>> {
|
||||
private:
|
||||
using map_type = detail::maybe_const_range<R>;
|
||||
using element_type = detail::uncvref_type<map_type>;
|
||||
|
||||
decltype(detail::tuple::get_formatters<element_type, Char>(
|
||||
detail::tuple_index_sequence<element_type>())) formatters_;
|
||||
bool no_delimiters_ = false;
|
||||
|
||||
public:
|
||||
FMT_CONSTEXPR formatter() {}
|
||||
|
||||
template <typename ParseContext>
|
||||
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
|
||||
auto it = ctx.begin();
|
||||
auto end = ctx.end();
|
||||
if (it != end) {
|
||||
if (detail::to_ascii(*it) == 'n') {
|
||||
no_delimiters_ = true;
|
||||
++it;
|
||||
}
|
||||
if (it != end && *it != '}') {
|
||||
if (*it != ':') report_error("invalid format specifier");
|
||||
++it;
|
||||
}
|
||||
ctx.advance_to(it);
|
||||
}
|
||||
detail::for_each(formatters_, detail::parse_empty_specs<ParseContext>{ctx});
|
||||
return it;
|
||||
}
|
||||
|
||||
template <typename FormatContext>
|
||||
auto format(map_type& map, FormatContext& ctx) const -> decltype(ctx.out()) {
|
||||
auto out = ctx.out();
|
||||
basic_string_view<Char> open = detail::string_literal<Char, '{'>{};
|
||||
if (!no_delimiters_) out = detail::copy<Char>(open, out);
|
||||
int i = 0;
|
||||
auto mapper = detail::range_mapper<buffered_context<Char>>();
|
||||
basic_string_view<Char> sep = detail::string_literal<Char, ',', ' '>{};
|
||||
for (auto&& value : map) {
|
||||
if (i > 0) out = detail::copy<Char>(sep, out);
|
||||
ctx.advance_to(out);
|
||||
detail::for_each2(formatters_, mapper.map(value),
|
||||
detail::format_tuple_element<FormatContext>{
|
||||
0, ctx, detail::string_literal<Char, ':', ' '>{}});
|
||||
++i;
|
||||
}
|
||||
basic_string_view<Char> close = detail::string_literal<Char, '}'>{};
|
||||
if (!no_delimiters_) out = detail::copy<Char>(close, out);
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
// A (debug_)string formatter.
|
||||
template <typename R, typename Char>
|
||||
struct formatter<
|
||||
R, Char,
|
||||
enable_if_t<range_format_kind<R, Char>::value == range_format::string ||
|
||||
range_format_kind<R, Char>::value ==
|
||||
range_format::debug_string>> {
|
||||
private:
|
||||
using range_type = detail::maybe_const_range<R>;
|
||||
using string_type =
|
||||
conditional_t<std::is_constructible<
|
||||
detail::std_string_view<Char>,
|
||||
decltype(detail::range_begin(std::declval<R>())),
|
||||
decltype(detail::range_end(std::declval<R>()))>::value,
|
||||
detail::std_string_view<Char>, std::basic_string<Char>>;
|
||||
|
||||
formatter<string_type, Char> underlying_;
|
||||
|
||||
public:
|
||||
template <typename ParseContext>
|
||||
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
|
||||
return underlying_.parse(ctx);
|
||||
}
|
||||
|
||||
template <typename FormatContext>
|
||||
auto format(range_type& range, FormatContext& ctx) const
|
||||
-> decltype(ctx.out()) {
|
||||
auto out = ctx.out();
|
||||
if (detail::const_check(range_format_kind<R, Char>::value ==
|
||||
range_format::debug_string))
|
||||
*out++ = '"';
|
||||
out = underlying_.format(
|
||||
string_type{detail::range_begin(range), detail::range_end(range)}, ctx);
|
||||
if (detail::const_check(range_format_kind<R, Char>::value ==
|
||||
range_format::debug_string))
|
||||
*out++ = '"';
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
template <typename It, typename Sentinel, typename Char = char>
|
||||
struct join_view : detail::view {
|
||||
It begin;
|
||||
Sentinel end;
|
||||
basic_string_view<Char> sep;
|
||||
|
||||
join_view(It b, Sentinel e, basic_string_view<Char> s)
|
||||
: begin(std::move(b)), end(e), sep(s) {}
|
||||
};
|
||||
|
||||
template <typename It, typename Sentinel, typename Char>
|
||||
struct formatter<join_view<It, Sentinel, Char>, Char> {
|
||||
private:
|
||||
using value_type =
|
||||
#ifdef __cpp_lib_ranges
|
||||
std::iter_value_t<It>;
|
||||
#else
|
||||
typename std::iterator_traits<It>::value_type;
|
||||
#endif
|
||||
formatter<remove_cvref_t<value_type>, Char> value_formatter_;
|
||||
|
||||
using view_ref = conditional_t<std::is_copy_constructible<It>::value,
|
||||
const join_view<It, Sentinel, Char>&,
|
||||
join_view<It, Sentinel, Char>&&>;
|
||||
|
||||
public:
|
||||
using nonlocking = void;
|
||||
|
||||
template <typename ParseContext>
|
||||
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* {
|
||||
return value_formatter_.parse(ctx);
|
||||
}
|
||||
|
||||
template <typename FormatContext>
|
||||
auto format(view_ref& value, FormatContext& ctx) const
|
||||
-> decltype(ctx.out()) {
|
||||
auto it = std::forward<view_ref>(value).begin;
|
||||
auto out = ctx.out();
|
||||
if (it == value.end) return out;
|
||||
out = value_formatter_.format(*it, ctx);
|
||||
++it;
|
||||
while (it != value.end) {
|
||||
out = detail::copy<Char>(value.sep.begin(), value.sep.end(), out);
|
||||
ctx.advance_to(out);
|
||||
out = value_formatter_.format(*it, ctx);
|
||||
++it;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
/// Returns a view that formats the iterator range `[begin, end)` with elements
|
||||
/// separated by `sep`.
|
||||
template <typename It, typename Sentinel>
|
||||
auto join(It begin, Sentinel end, string_view sep) -> join_view<It, Sentinel> {
|
||||
return {std::move(begin), end, sep};
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a view that formats `range` with elements separated by `sep`.
|
||||
*
|
||||
* **Example**:
|
||||
*
|
||||
* auto v = std::vector<int>{1, 2, 3};
|
||||
* fmt::print("{}", fmt::join(v, ", "));
|
||||
* // Output: 1, 2, 3
|
||||
*
|
||||
* `fmt::join` applies passed format specifiers to the range elements:
|
||||
*
|
||||
* fmt::print("{:02}", fmt::join(v, ", "));
|
||||
* // Output: 01, 02, 03
|
||||
*/
|
||||
template <typename Range>
|
||||
auto join(Range&& r, string_view sep)
|
||||
-> join_view<decltype(detail::range_begin(r)),
|
||||
decltype(detail::range_end(r))> {
|
||||
return {detail::range_begin(r), detail::range_end(r), sep};
|
||||
}
|
||||
|
||||
template <typename Char, typename... T> struct tuple_join_view : detail::view {
|
||||
const std::tuple<T...>& tuple;
|
||||
basic_string_view<Char> sep;
|
||||
|
||||
tuple_join_view(const std::tuple<T...>& t, basic_string_view<Char> s)
|
||||
: tuple(t), sep{s} {}
|
||||
};
|
||||
|
||||
// Define FMT_TUPLE_JOIN_SPECIFIERS to enable experimental format specifiers
|
||||
// support in tuple_join. It is disabled by default because of issues with
|
||||
// the dynamic width and precision.
|
||||
#ifndef FMT_TUPLE_JOIN_SPECIFIERS
|
||||
# define FMT_TUPLE_JOIN_SPECIFIERS 0
|
||||
#endif
|
||||
|
||||
template <typename Char, typename... T>
|
||||
struct formatter<tuple_join_view<Char, T...>, Char> {
|
||||
template <typename ParseContext>
|
||||
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
|
||||
return do_parse(ctx, std::integral_constant<size_t, sizeof...(T)>());
|
||||
}
|
||||
|
||||
template <typename FormatContext>
|
||||
auto format(const tuple_join_view<Char, T...>& value,
|
||||
FormatContext& ctx) const -> typename FormatContext::iterator {
|
||||
return do_format(value, ctx,
|
||||
std::integral_constant<size_t, sizeof...(T)>());
|
||||
}
|
||||
|
||||
private:
|
||||
std::tuple<formatter<typename std::decay<T>::type, Char>...> formatters_;
|
||||
|
||||
template <typename ParseContext>
|
||||
FMT_CONSTEXPR auto do_parse(ParseContext& ctx,
|
||||
std::integral_constant<size_t, 0>)
|
||||
-> decltype(ctx.begin()) {
|
||||
return ctx.begin();
|
||||
}
|
||||
|
||||
template <typename ParseContext, size_t N>
|
||||
FMT_CONSTEXPR auto do_parse(ParseContext& ctx,
|
||||
std::integral_constant<size_t, N>)
|
||||
-> decltype(ctx.begin()) {
|
||||
auto end = ctx.begin();
|
||||
#if FMT_TUPLE_JOIN_SPECIFIERS
|
||||
end = std::get<sizeof...(T) - N>(formatters_).parse(ctx);
|
||||
if (N > 1) {
|
||||
auto end1 = do_parse(ctx, std::integral_constant<size_t, N - 1>());
|
||||
if (end != end1)
|
||||
report_error("incompatible format specs for tuple elements");
|
||||
}
|
||||
#endif
|
||||
return end;
|
||||
}
|
||||
|
||||
template <typename FormatContext>
|
||||
auto do_format(const tuple_join_view<Char, T...>&, FormatContext& ctx,
|
||||
std::integral_constant<size_t, 0>) const ->
|
||||
typename FormatContext::iterator {
|
||||
return ctx.out();
|
||||
}
|
||||
|
||||
template <typename FormatContext, size_t N>
|
||||
auto do_format(const tuple_join_view<Char, T...>& value, FormatContext& ctx,
|
||||
std::integral_constant<size_t, N>) const ->
|
||||
typename FormatContext::iterator {
|
||||
auto out = std::get<sizeof...(T) - N>(formatters_)
|
||||
.format(std::get<sizeof...(T) - N>(value.tuple), ctx);
|
||||
if (N <= 1) return out;
|
||||
out = detail::copy<Char>(value.sep, out);
|
||||
ctx.advance_to(out);
|
||||
return do_format(value, ctx, std::integral_constant<size_t, N - 1>());
|
||||
}
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
// Check if T has an interface like a container adaptor (e.g. std::stack,
|
||||
// std::queue, std::priority_queue).
|
||||
template <typename T> class is_container_adaptor_like {
|
||||
template <typename U> static auto check(U* p) -> typename U::container_type;
|
||||
template <typename> static void check(...);
|
||||
|
||||
public:
|
||||
static constexpr const bool value =
|
||||
!std::is_void<decltype(check<T>(nullptr))>::value;
|
||||
};
|
||||
|
||||
template <typename Container> struct all {
|
||||
const Container& c;
|
||||
auto begin() const -> typename Container::const_iterator { return c.begin(); }
|
||||
auto end() const -> typename Container::const_iterator { return c.end(); }
|
||||
};
|
||||
} // namespace detail
|
||||
|
||||
template <typename T, typename Char>
|
||||
struct formatter<
|
||||
T, Char,
|
||||
enable_if_t<conjunction<detail::is_container_adaptor_like<T>,
|
||||
bool_constant<range_format_kind<T, Char>::value ==
|
||||
range_format::disabled>>::value>>
|
||||
: formatter<detail::all<typename T::container_type>, Char> {
|
||||
using all = detail::all<typename T::container_type>;
|
||||
template <typename FormatContext>
|
||||
auto format(const T& t, FormatContext& ctx) const -> decltype(ctx.out()) {
|
||||
struct getter : T {
|
||||
static auto get(const T& t) -> all {
|
||||
return {t.*(&getter::c)}; // Access c through the derived class.
|
||||
}
|
||||
};
|
||||
return formatter<all>::format(getter::get(t), ctx);
|
||||
}
|
||||
};
|
||||
|
||||
FMT_BEGIN_EXPORT
|
||||
|
||||
/**
|
||||
* Returns an object that formats `std::tuple` with elements separated by `sep`.
|
||||
*
|
||||
* **Example**:
|
||||
*
|
||||
* auto t = std::tuple<int, char>{1, 'a'};
|
||||
* fmt::print("{}", fmt::join(t, ", "));
|
||||
* // Output: 1, a
|
||||
*/
|
||||
template <typename... T>
|
||||
FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple, string_view sep)
|
||||
-> tuple_join_view<char, T...> {
|
||||
return {tuple, sep};
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns an object that formats `std::initializer_list` with elements
|
||||
* separated by `sep`.
|
||||
*
|
||||
* **Example**:
|
||||
*
|
||||
* fmt::print("{}", fmt::join({1, 2, 3}, ", "));
|
||||
* // Output: "1, 2, 3"
|
||||
*/
|
||||
template <typename T>
|
||||
auto join(std::initializer_list<T> list, string_view sep)
|
||||
-> join_view<const T*, const T*> {
|
||||
return join(std::begin(list), std::end(list), sep);
|
||||
}
|
||||
|
||||
FMT_END_EXPORT
|
||||
FMT_END_NAMESPACE
|
||||
|
||||
#endif // FMT_RANGES_H_
|
||||
|
|
@ -0,0 +1,699 @@
|
|||
// Formatting library for C++ - formatters for standard library types
|
||||
//
|
||||
// Copyright (c) 2012 - present, Victor Zverovich
|
||||
// All rights reserved.
|
||||
//
|
||||
// For the license information refer to format.h.
|
||||
|
||||
#ifndef FMT_STD_H_
|
||||
#define FMT_STD_H_
|
||||
|
||||
#include "format.h"
|
||||
#include "ostream.h"
|
||||
|
||||
#ifndef FMT_MODULE
|
||||
# include <atomic>
|
||||
# include <bitset>
|
||||
# include <complex>
|
||||
# include <cstdlib>
|
||||
# include <exception>
|
||||
# include <memory>
|
||||
# include <thread>
|
||||
# include <type_traits>
|
||||
# include <typeinfo>
|
||||
# include <utility>
|
||||
# include <vector>
|
||||
|
||||
// Check FMT_CPLUSPLUS to suppress a bogus warning in MSVC.
|
||||
# if FMT_CPLUSPLUS >= 201703L
|
||||
# if FMT_HAS_INCLUDE(<filesystem>)
|
||||
# include <filesystem>
|
||||
# endif
|
||||
# if FMT_HAS_INCLUDE(<variant>)
|
||||
# include <variant>
|
||||
# endif
|
||||
# if FMT_HAS_INCLUDE(<optional>)
|
||||
# include <optional>
|
||||
# endif
|
||||
# endif
|
||||
// Use > instead of >= in the version check because <source_location> may be
|
||||
// available after C++17 but before C++20 is marked as implemented.
|
||||
# if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE(<source_location>)
|
||||
# include <source_location>
|
||||
# endif
|
||||
# if FMT_CPLUSPLUS > 202002L && FMT_HAS_INCLUDE(<expected>)
|
||||
# include <expected>
|
||||
# endif
|
||||
#endif // FMT_MODULE
|
||||
|
||||
#if FMT_HAS_INCLUDE(<version>)
|
||||
# include <version>
|
||||
#endif
|
||||
|
||||
// GCC 4 does not support FMT_HAS_INCLUDE.
|
||||
#if FMT_HAS_INCLUDE(<cxxabi.h>) || defined(__GLIBCXX__)
|
||||
# include <cxxabi.h>
|
||||
// Android NDK with gabi++ library on some architectures does not implement
|
||||
// abi::__cxa_demangle().
|
||||
# ifndef __GABIXX_CXXABI_H__
|
||||
# define FMT_HAS_ABI_CXA_DEMANGLE
|
||||
# endif
|
||||
#endif
|
||||
|
||||
// For older Xcode versions, __cpp_lib_xxx flags are inaccurately defined.
|
||||
#ifndef FMT_CPP_LIB_FILESYSTEM
|
||||
# ifdef __cpp_lib_filesystem
|
||||
# define FMT_CPP_LIB_FILESYSTEM __cpp_lib_filesystem
|
||||
# else
|
||||
# define FMT_CPP_LIB_FILESYSTEM 0
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef FMT_CPP_LIB_VARIANT
|
||||
# ifdef __cpp_lib_variant
|
||||
# define FMT_CPP_LIB_VARIANT __cpp_lib_variant
|
||||
# else
|
||||
# define FMT_CPP_LIB_VARIANT 0
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if FMT_CPP_LIB_FILESYSTEM
|
||||
FMT_BEGIN_NAMESPACE
|
||||
|
||||
namespace detail {
|
||||
|
||||
template <typename Char, typename PathChar>
|
||||
auto get_path_string(const std::filesystem::path& p,
|
||||
const std::basic_string<PathChar>& native) {
|
||||
if constexpr (std::is_same_v<Char, char> && std::is_same_v<PathChar, wchar_t>)
|
||||
return to_utf8<wchar_t>(native, to_utf8_error_policy::replace);
|
||||
else
|
||||
return p.string<Char>();
|
||||
}
|
||||
|
||||
template <typename Char, typename PathChar>
|
||||
void write_escaped_path(basic_memory_buffer<Char>& quoted,
|
||||
const std::filesystem::path& p,
|
||||
const std::basic_string<PathChar>& native) {
|
||||
if constexpr (std::is_same_v<Char, char> &&
|
||||
std::is_same_v<PathChar, wchar_t>) {
|
||||
auto buf = basic_memory_buffer<wchar_t>();
|
||||
write_escaped_string<wchar_t>(std::back_inserter(buf), native);
|
||||
bool valid = to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()});
|
||||
FMT_ASSERT(valid, "invalid utf16");
|
||||
} else if constexpr (std::is_same_v<Char, PathChar>) {
|
||||
write_escaped_string<std::filesystem::path::value_type>(
|
||||
std::back_inserter(quoted), native);
|
||||
} else {
|
||||
write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>());
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
FMT_EXPORT
|
||||
template <typename Char> struct formatter<std::filesystem::path, Char> {
|
||||
private:
|
||||
format_specs specs_;
|
||||
detail::arg_ref<Char> width_ref_;
|
||||
bool debug_ = false;
|
||||
char path_type_ = 0;
|
||||
|
||||
public:
|
||||
FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; }
|
||||
|
||||
template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
|
||||
auto it = ctx.begin(), end = ctx.end();
|
||||
if (it == end) return it;
|
||||
|
||||
it = detail::parse_align(it, end, specs_);
|
||||
if (it == end) return it;
|
||||
|
||||
it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx);
|
||||
if (it != end && *it == '?') {
|
||||
debug_ = true;
|
||||
++it;
|
||||
}
|
||||
if (it != end && (*it == 'g')) path_type_ = detail::to_ascii(*it++);
|
||||
return it;
|
||||
}
|
||||
|
||||
template <typename FormatContext>
|
||||
auto format(const std::filesystem::path& p, FormatContext& ctx) const {
|
||||
auto specs = specs_;
|
||||
auto path_string =
|
||||
!path_type_ ? p.native()
|
||||
: p.generic_string<std::filesystem::path::value_type>();
|
||||
|
||||
detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_,
|
||||
ctx);
|
||||
if (!debug_) {
|
||||
auto s = detail::get_path_string<Char>(p, path_string);
|
||||
return detail::write(ctx.out(), basic_string_view<Char>(s), specs);
|
||||
}
|
||||
auto quoted = basic_memory_buffer<Char>();
|
||||
detail::write_escaped_path(quoted, p, path_string);
|
||||
return detail::write(ctx.out(),
|
||||
basic_string_view<Char>(quoted.data(), quoted.size()),
|
||||
specs);
|
||||
}
|
||||
};
|
||||
|
||||
class path : public std::filesystem::path {
|
||||
public:
|
||||
auto display_string() const -> std::string {
|
||||
const std::filesystem::path& base = *this;
|
||||
return fmt::format(FMT_STRING("{}"), base);
|
||||
}
|
||||
auto system_string() const -> std::string { return string(); }
|
||||
|
||||
auto generic_display_string() const -> std::string {
|
||||
const std::filesystem::path& base = *this;
|
||||
return fmt::format(FMT_STRING("{:g}"), base);
|
||||
}
|
||||
auto generic_system_string() const -> std::string { return generic_string(); }
|
||||
};
|
||||
|
||||
FMT_END_NAMESPACE
|
||||
#endif // FMT_CPP_LIB_FILESYSTEM
|
||||
|
||||
FMT_BEGIN_NAMESPACE
|
||||
FMT_EXPORT
|
||||
template <std::size_t N, typename Char>
|
||||
struct formatter<std::bitset<N>, Char> : nested_formatter<string_view> {
|
||||
private:
|
||||
// Functor because C++11 doesn't support generic lambdas.
|
||||
struct writer {
|
||||
const std::bitset<N>& bs;
|
||||
|
||||
template <typename OutputIt>
|
||||
FMT_CONSTEXPR auto operator()(OutputIt out) -> OutputIt {
|
||||
for (auto pos = N; pos > 0; --pos) {
|
||||
out = detail::write<Char>(out, bs[pos - 1] ? Char('1') : Char('0'));
|
||||
}
|
||||
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
public:
|
||||
template <typename FormatContext>
|
||||
auto format(const std::bitset<N>& bs, FormatContext& ctx) const
|
||||
-> decltype(ctx.out()) {
|
||||
return write_padded(ctx, writer{bs});
|
||||
}
|
||||
};
|
||||
|
||||
FMT_EXPORT
|
||||
template <typename Char>
|
||||
struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {};
|
||||
FMT_END_NAMESPACE
|
||||
|
||||
#ifdef __cpp_lib_optional
|
||||
FMT_BEGIN_NAMESPACE
|
||||
FMT_EXPORT
|
||||
template <typename T, typename Char>
|
||||
struct formatter<std::optional<T>, Char,
|
||||
std::enable_if_t<is_formattable<T, Char>::value>> {
|
||||
private:
|
||||
formatter<T, Char> underlying_;
|
||||
static constexpr basic_string_view<Char> optional =
|
||||
detail::string_literal<Char, 'o', 'p', 't', 'i', 'o', 'n', 'a', 'l',
|
||||
'('>{};
|
||||
static constexpr basic_string_view<Char> none =
|
||||
detail::string_literal<Char, 'n', 'o', 'n', 'e'>{};
|
||||
|
||||
template <class U>
|
||||
FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, bool set)
|
||||
-> decltype(u.set_debug_format(set)) {
|
||||
u.set_debug_format(set);
|
||||
}
|
||||
|
||||
template <class U>
|
||||
FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {}
|
||||
|
||||
public:
|
||||
template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
|
||||
maybe_set_debug_format(underlying_, true);
|
||||
return underlying_.parse(ctx);
|
||||
}
|
||||
|
||||
template <typename FormatContext>
|
||||
auto format(const std::optional<T>& opt, FormatContext& ctx) const
|
||||
-> decltype(ctx.out()) {
|
||||
if (!opt) return detail::write<Char>(ctx.out(), none);
|
||||
|
||||
auto out = ctx.out();
|
||||
out = detail::write<Char>(out, optional);
|
||||
ctx.advance_to(out);
|
||||
out = underlying_.format(*opt, ctx);
|
||||
return detail::write(out, ')');
|
||||
}
|
||||
};
|
||||
FMT_END_NAMESPACE
|
||||
#endif // __cpp_lib_optional
|
||||
|
||||
#if defined(__cpp_lib_expected) || FMT_CPP_LIB_VARIANT
|
||||
|
||||
FMT_BEGIN_NAMESPACE
|
||||
namespace detail {
|
||||
|
||||
template <typename Char, typename OutputIt, typename T>
|
||||
auto write_escaped_alternative(OutputIt out, const T& v) -> OutputIt {
|
||||
if constexpr (has_to_string_view<T>::value)
|
||||
return write_escaped_string<Char>(out, detail::to_string_view(v));
|
||||
if constexpr (std::is_same_v<T, Char>) return write_escaped_char(out, v);
|
||||
return write<Char>(out, v);
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
FMT_END_NAMESPACE
|
||||
#endif
|
||||
|
||||
#ifdef __cpp_lib_expected
|
||||
FMT_BEGIN_NAMESPACE
|
||||
|
||||
FMT_EXPORT
|
||||
template <typename T, typename E, typename Char>
|
||||
struct formatter<std::expected<T, E>, Char,
|
||||
std::enable_if_t<is_formattable<T, Char>::value &&
|
||||
is_formattable<E, Char>::value>> {
|
||||
template <typename ParseContext>
|
||||
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
|
||||
return ctx.begin();
|
||||
}
|
||||
|
||||
template <typename FormatContext>
|
||||
auto format(const std::expected<T, E>& value, FormatContext& ctx) const
|
||||
-> decltype(ctx.out()) {
|
||||
auto out = ctx.out();
|
||||
|
||||
if (value.has_value()) {
|
||||
out = detail::write<Char>(out, "expected(");
|
||||
out = detail::write_escaped_alternative<Char>(out, *value);
|
||||
} else {
|
||||
out = detail::write<Char>(out, "unexpected(");
|
||||
out = detail::write_escaped_alternative<Char>(out, value.error());
|
||||
}
|
||||
*out++ = ')';
|
||||
return out;
|
||||
}
|
||||
};
|
||||
FMT_END_NAMESPACE
|
||||
#endif // __cpp_lib_expected
|
||||
|
||||
#ifdef __cpp_lib_source_location
|
||||
FMT_BEGIN_NAMESPACE
|
||||
FMT_EXPORT
|
||||
template <> struct formatter<std::source_location> {
|
||||
template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
|
||||
return ctx.begin();
|
||||
}
|
||||
|
||||
template <typename FormatContext>
|
||||
auto format(const std::source_location& loc, FormatContext& ctx) const
|
||||
-> decltype(ctx.out()) {
|
||||
auto out = ctx.out();
|
||||
out = detail::write(out, loc.file_name());
|
||||
out = detail::write(out, ':');
|
||||
out = detail::write<char>(out, loc.line());
|
||||
out = detail::write(out, ':');
|
||||
out = detail::write<char>(out, loc.column());
|
||||
out = detail::write(out, ": ");
|
||||
out = detail::write(out, loc.function_name());
|
||||
return out;
|
||||
}
|
||||
};
|
||||
FMT_END_NAMESPACE
|
||||
#endif
|
||||
|
||||
#if FMT_CPP_LIB_VARIANT
|
||||
FMT_BEGIN_NAMESPACE
|
||||
namespace detail {
|
||||
|
||||
template <typename T>
|
||||
using variant_index_sequence =
|
||||
std::make_index_sequence<std::variant_size<T>::value>;
|
||||
|
||||
template <typename> struct is_variant_like_ : std::false_type {};
|
||||
template <typename... Types>
|
||||
struct is_variant_like_<std::variant<Types...>> : std::true_type {};
|
||||
|
||||
// formattable element check.
|
||||
template <typename T, typename C> class is_variant_formattable_ {
|
||||
template <std::size_t... Is>
|
||||
static std::conjunction<
|
||||
is_formattable<std::variant_alternative_t<Is, T>, C>...>
|
||||
check(std::index_sequence<Is...>);
|
||||
|
||||
public:
|
||||
static constexpr const bool value =
|
||||
decltype(check(variant_index_sequence<T>{}))::value;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template <typename T> struct is_variant_like {
|
||||
static constexpr const bool value = detail::is_variant_like_<T>::value;
|
||||
};
|
||||
|
||||
template <typename T, typename C> struct is_variant_formattable {
|
||||
static constexpr const bool value =
|
||||
detail::is_variant_formattable_<T, C>::value;
|
||||
};
|
||||
|
||||
FMT_EXPORT
|
||||
template <typename Char> struct formatter<std::monostate, Char> {
|
||||
template <typename ParseContext>
|
||||
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
|
||||
return ctx.begin();
|
||||
}
|
||||
|
||||
template <typename FormatContext>
|
||||
auto format(const std::monostate&, FormatContext& ctx) const
|
||||
-> decltype(ctx.out()) {
|
||||
return detail::write<Char>(ctx.out(), "monostate");
|
||||
}
|
||||
};
|
||||
|
||||
FMT_EXPORT
|
||||
template <typename Variant, typename Char>
|
||||
struct formatter<
|
||||
Variant, Char,
|
||||
std::enable_if_t<std::conjunction_v<
|
||||
is_variant_like<Variant>, is_variant_formattable<Variant, Char>>>> {
|
||||
template <typename ParseContext>
|
||||
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
|
||||
return ctx.begin();
|
||||
}
|
||||
|
||||
template <typename FormatContext>
|
||||
auto format(const Variant& value, FormatContext& ctx) const
|
||||
-> decltype(ctx.out()) {
|
||||
auto out = ctx.out();
|
||||
|
||||
out = detail::write<Char>(out, "variant(");
|
||||
FMT_TRY {
|
||||
std::visit(
|
||||
[&](const auto& v) {
|
||||
out = detail::write_escaped_alternative<Char>(out, v);
|
||||
},
|
||||
value);
|
||||
}
|
||||
FMT_CATCH(const std::bad_variant_access&) {
|
||||
detail::write<Char>(out, "valueless by exception");
|
||||
}
|
||||
*out++ = ')';
|
||||
return out;
|
||||
}
|
||||
};
|
||||
FMT_END_NAMESPACE
|
||||
#endif // FMT_CPP_LIB_VARIANT
|
||||
|
||||
FMT_BEGIN_NAMESPACE
|
||||
FMT_EXPORT
|
||||
template <typename Char> struct formatter<std::error_code, Char> {
|
||||
template <typename ParseContext>
|
||||
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
|
||||
return ctx.begin();
|
||||
}
|
||||
|
||||
template <typename FormatContext>
|
||||
FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
|
||||
-> decltype(ctx.out()) {
|
||||
auto out = ctx.out();
|
||||
out = detail::write_bytes<Char>(out, ec.category().name(), format_specs());
|
||||
out = detail::write<Char>(out, Char(':'));
|
||||
out = detail::write<Char>(out, ec.value());
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
#if FMT_USE_RTTI
|
||||
namespace detail {
|
||||
|
||||
template <typename Char, typename OutputIt>
|
||||
auto write_demangled_name(OutputIt out, const std::type_info& ti) -> OutputIt {
|
||||
# ifdef FMT_HAS_ABI_CXA_DEMANGLE
|
||||
int status = 0;
|
||||
std::size_t size = 0;
|
||||
std::unique_ptr<char, void (*)(void*)> demangled_name_ptr(
|
||||
abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free);
|
||||
|
||||
string_view demangled_name_view;
|
||||
if (demangled_name_ptr) {
|
||||
demangled_name_view = demangled_name_ptr.get();
|
||||
|
||||
// Normalization of stdlib inline namespace names.
|
||||
// libc++ inline namespaces.
|
||||
// std::__1::* -> std::*
|
||||
// std::__1::__fs::* -> std::*
|
||||
// libstdc++ inline namespaces.
|
||||
// std::__cxx11::* -> std::*
|
||||
// std::filesystem::__cxx11::* -> std::filesystem::*
|
||||
if (demangled_name_view.starts_with("std::")) {
|
||||
char* begin = demangled_name_ptr.get();
|
||||
char* to = begin + 5; // std::
|
||||
for (char *from = to, *end = begin + demangled_name_view.size();
|
||||
from < end;) {
|
||||
// This is safe, because demangled_name is NUL-terminated.
|
||||
if (from[0] == '_' && from[1] == '_') {
|
||||
char* next = from + 1;
|
||||
while (next < end && *next != ':') next++;
|
||||
if (next[0] == ':' && next[1] == ':') {
|
||||
from = next + 2;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
*to++ = *from++;
|
||||
}
|
||||
demangled_name_view = {begin, detail::to_unsigned(to - begin)};
|
||||
}
|
||||
} else {
|
||||
demangled_name_view = string_view(ti.name());
|
||||
}
|
||||
return detail::write_bytes<Char>(out, demangled_name_view);
|
||||
# elif FMT_MSC_VERSION
|
||||
const string_view demangled_name(ti.name());
|
||||
for (std::size_t i = 0; i < demangled_name.size(); ++i) {
|
||||
auto sub = demangled_name;
|
||||
sub.remove_prefix(i);
|
||||
if (sub.starts_with("enum ")) {
|
||||
i += 4;
|
||||
continue;
|
||||
}
|
||||
if (sub.starts_with("class ") || sub.starts_with("union ")) {
|
||||
i += 5;
|
||||
continue;
|
||||
}
|
||||
if (sub.starts_with("struct ")) {
|
||||
i += 6;
|
||||
continue;
|
||||
}
|
||||
if (*sub.begin() != ' ') *out++ = *sub.begin();
|
||||
}
|
||||
return out;
|
||||
# else
|
||||
return detail::write_bytes<Char>(out, string_view(ti.name()));
|
||||
# endif
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
FMT_EXPORT
|
||||
template <typename Char>
|
||||
struct formatter<std::type_info, Char // DEPRECATED! Mixing code unit types.
|
||||
> {
|
||||
public:
|
||||
FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
|
||||
-> decltype(ctx.begin()) {
|
||||
return ctx.begin();
|
||||
}
|
||||
|
||||
template <typename Context>
|
||||
auto format(const std::type_info& ti, Context& ctx) const
|
||||
-> decltype(ctx.out()) {
|
||||
return detail::write_demangled_name<Char>(ctx.out(), ti);
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
||||
FMT_EXPORT
|
||||
template <typename T, typename Char>
|
||||
struct formatter<
|
||||
T, Char, // DEPRECATED! Mixing code unit types.
|
||||
typename std::enable_if<std::is_base_of<std::exception, T>::value>::type> {
|
||||
private:
|
||||
bool with_typename_ = false;
|
||||
|
||||
public:
|
||||
FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
|
||||
-> decltype(ctx.begin()) {
|
||||
auto it = ctx.begin();
|
||||
auto end = ctx.end();
|
||||
if (it == end || *it == '}') return it;
|
||||
if (*it == 't') {
|
||||
++it;
|
||||
with_typename_ = FMT_USE_RTTI != 0;
|
||||
}
|
||||
return it;
|
||||
}
|
||||
|
||||
template <typename Context>
|
||||
auto format(const std::exception& ex, Context& ctx) const
|
||||
-> decltype(ctx.out()) {
|
||||
auto out = ctx.out();
|
||||
#if FMT_USE_RTTI
|
||||
if (with_typename_) {
|
||||
out = detail::write_demangled_name<Char>(out, typeid(ex));
|
||||
*out++ = ':';
|
||||
*out++ = ' ';
|
||||
}
|
||||
#endif
|
||||
return detail::write_bytes<Char>(out, string_view(ex.what()));
|
||||
}
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
template <typename T, typename Enable = void>
|
||||
struct has_flip : std::false_type {};
|
||||
|
||||
template <typename T>
|
||||
struct has_flip<T, void_t<decltype(std::declval<T>().flip())>>
|
||||
: std::true_type {};
|
||||
|
||||
template <typename T> struct is_bit_reference_like {
|
||||
static constexpr const bool value =
|
||||
std::is_convertible<T, bool>::value &&
|
||||
std::is_nothrow_assignable<T, bool>::value && has_flip<T>::value;
|
||||
};
|
||||
|
||||
#ifdef _LIBCPP_VERSION
|
||||
|
||||
// Workaround for libc++ incompatibility with C++ standard.
|
||||
// According to the Standard, `bitset::operator[] const` returns bool.
|
||||
template <typename C>
|
||||
struct is_bit_reference_like<std::__bit_const_reference<C>> {
|
||||
static constexpr const bool value = true;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// We can't use std::vector<bool, Allocator>::reference and
|
||||
// std::bitset<N>::reference because the compiler can't deduce Allocator and N
|
||||
// in partial specialization.
|
||||
FMT_EXPORT
|
||||
template <typename BitRef, typename Char>
|
||||
struct formatter<BitRef, Char,
|
||||
enable_if_t<detail::is_bit_reference_like<BitRef>::value>>
|
||||
: formatter<bool, Char> {
|
||||
template <typename FormatContext>
|
||||
FMT_CONSTEXPR auto format(const BitRef& v, FormatContext& ctx) const
|
||||
-> decltype(ctx.out()) {
|
||||
return formatter<bool, Char>::format(v, ctx);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T, typename Deleter>
|
||||
auto ptr(const std::unique_ptr<T, Deleter>& p) -> const void* {
|
||||
return p.get();
|
||||
}
|
||||
template <typename T> auto ptr(const std::shared_ptr<T>& p) -> const void* {
|
||||
return p.get();
|
||||
}
|
||||
|
||||
FMT_EXPORT
|
||||
template <typename T, typename Char>
|
||||
struct formatter<std::atomic<T>, Char,
|
||||
enable_if_t<is_formattable<T, Char>::value>>
|
||||
: formatter<T, Char> {
|
||||
template <typename FormatContext>
|
||||
auto format(const std::atomic<T>& v, FormatContext& ctx) const
|
||||
-> decltype(ctx.out()) {
|
||||
return formatter<T, Char>::format(v.load(), ctx);
|
||||
}
|
||||
};
|
||||
|
||||
#ifdef __cpp_lib_atomic_flag_test
|
||||
FMT_EXPORT
|
||||
template <typename Char>
|
||||
struct formatter<std::atomic_flag, Char> : formatter<bool, Char> {
|
||||
template <typename FormatContext>
|
||||
auto format(const std::atomic_flag& v, FormatContext& ctx) const
|
||||
-> decltype(ctx.out()) {
|
||||
return formatter<bool, Char>::format(v.test(), ctx);
|
||||
}
|
||||
};
|
||||
#endif // __cpp_lib_atomic_flag_test
|
||||
|
||||
FMT_EXPORT
|
||||
template <typename T, typename Char> struct formatter<std::complex<T>, Char> {
|
||||
private:
|
||||
detail::dynamic_format_specs<Char> specs_;
|
||||
|
||||
template <typename FormatContext, typename OutputIt>
|
||||
FMT_CONSTEXPR auto do_format(const std::complex<T>& c,
|
||||
detail::dynamic_format_specs<Char>& specs,
|
||||
FormatContext& ctx, OutputIt out) const
|
||||
-> OutputIt {
|
||||
if (c.real() != 0) {
|
||||
*out++ = Char('(');
|
||||
out = detail::write<Char>(out, c.real(), specs, ctx.locale());
|
||||
specs.sign = sign::plus;
|
||||
out = detail::write<Char>(out, c.imag(), specs, ctx.locale());
|
||||
if (!detail::isfinite(c.imag())) *out++ = Char(' ');
|
||||
*out++ = Char('i');
|
||||
*out++ = Char(')');
|
||||
return out;
|
||||
}
|
||||
out = detail::write<Char>(out, c.imag(), specs, ctx.locale());
|
||||
if (!detail::isfinite(c.imag())) *out++ = Char(' ');
|
||||
*out++ = Char('i');
|
||||
return out;
|
||||
}
|
||||
|
||||
public:
|
||||
FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
|
||||
-> decltype(ctx.begin()) {
|
||||
if (ctx.begin() == ctx.end() || *ctx.begin() == '}') return ctx.begin();
|
||||
return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx,
|
||||
detail::type_constant<T, Char>::value);
|
||||
}
|
||||
|
||||
template <typename FormatContext>
|
||||
auto format(const std::complex<T>& c, FormatContext& ctx) const
|
||||
-> decltype(ctx.out()) {
|
||||
auto specs = specs_;
|
||||
if (specs.width_ref.kind != detail::arg_id_kind::none ||
|
||||
specs.precision_ref.kind != detail::arg_id_kind::none) {
|
||||
detail::handle_dynamic_spec<detail::width_checker>(specs.width,
|
||||
specs.width_ref, ctx);
|
||||
detail::handle_dynamic_spec<detail::precision_checker>(
|
||||
specs.precision, specs.precision_ref, ctx);
|
||||
}
|
||||
|
||||
if (specs.width == 0) return do_format(c, specs, ctx, ctx.out());
|
||||
auto buf = basic_memory_buffer<Char>();
|
||||
|
||||
auto outer_specs = format_specs();
|
||||
outer_specs.width = specs.width;
|
||||
outer_specs.fill = specs.fill;
|
||||
outer_specs.align = specs.align;
|
||||
|
||||
specs.width = 0;
|
||||
specs.fill = {};
|
||||
specs.align = align::none;
|
||||
|
||||
do_format(c, specs, ctx, basic_appender<Char>(buf));
|
||||
return detail::write<Char>(ctx.out(),
|
||||
basic_string_view<Char>(buf.data(), buf.size()),
|
||||
outer_specs);
|
||||
}
|
||||
};
|
||||
|
||||
FMT_END_NAMESPACE
|
||||
#endif // FMT_STD_H_
|
||||
|
|
@ -0,0 +1,322 @@
|
|||
// Formatting library for C++ - optional wchar_t and exotic character support
|
||||
//
|
||||
// Copyright (c) 2012 - present, Victor Zverovich
|
||||
// All rights reserved.
|
||||
//
|
||||
// For the license information refer to format.h.
|
||||
|
||||
#ifndef FMT_XCHAR_H_
|
||||
#define FMT_XCHAR_H_
|
||||
|
||||
#include "color.h"
|
||||
#include "format.h"
|
||||
#include "ranges.h"
|
||||
|
||||
#ifndef FMT_MODULE
|
||||
# include <cwchar>
|
||||
# if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
|
||||
# include <locale>
|
||||
# endif
|
||||
#endif
|
||||
|
||||
FMT_BEGIN_NAMESPACE
|
||||
namespace detail {
|
||||
|
||||
template <typename T>
|
||||
using is_exotic_char = bool_constant<!std::is_same<T, char>::value>;
|
||||
|
||||
template <typename S, typename = void> struct format_string_char {};
|
||||
|
||||
template <typename S>
|
||||
struct format_string_char<
|
||||
S, void_t<decltype(sizeof(detail::to_string_view(std::declval<S>())))>> {
|
||||
using type = char_t<S>;
|
||||
};
|
||||
|
||||
template <typename S>
|
||||
struct format_string_char<S, enable_if_t<is_compile_string<S>::value>> {
|
||||
using type = typename S::char_type;
|
||||
};
|
||||
|
||||
template <typename S>
|
||||
using format_string_char_t = typename format_string_char<S>::type;
|
||||
|
||||
inline auto write_loc(basic_appender<wchar_t> out, loc_value value,
|
||||
const format_specs& specs, locale_ref loc) -> bool {
|
||||
#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
|
||||
auto& numpunct =
|
||||
std::use_facet<std::numpunct<wchar_t>>(loc.get<std::locale>());
|
||||
auto separator = std::wstring();
|
||||
auto grouping = numpunct.grouping();
|
||||
if (!grouping.empty()) separator = std::wstring(1, numpunct.thousands_sep());
|
||||
return value.visit(loc_writer<wchar_t>{out, specs, separator, grouping, {}});
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
} // namespace detail
|
||||
|
||||
FMT_BEGIN_EXPORT
|
||||
|
||||
using wstring_view = basic_string_view<wchar_t>;
|
||||
using wformat_parse_context = basic_format_parse_context<wchar_t>;
|
||||
using wformat_context = buffered_context<wchar_t>;
|
||||
using wformat_args = basic_format_args<wformat_context>;
|
||||
using wmemory_buffer = basic_memory_buffer<wchar_t>;
|
||||
|
||||
#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
|
||||
// Workaround broken conversion on older gcc.
|
||||
template <typename... Args> using wformat_string = wstring_view;
|
||||
inline auto runtime(wstring_view s) -> wstring_view { return s; }
|
||||
#else
|
||||
template <typename... Args>
|
||||
using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;
|
||||
inline auto runtime(wstring_view s) -> runtime_format_string<wchar_t> {
|
||||
return {{s}};
|
||||
}
|
||||
#endif
|
||||
|
||||
template <> struct is_char<wchar_t> : std::true_type {};
|
||||
template <> struct is_char<char16_t> : std::true_type {};
|
||||
template <> struct is_char<char32_t> : std::true_type {};
|
||||
|
||||
#ifdef __cpp_char8_t
|
||||
template <>
|
||||
struct is_char<char8_t> : bool_constant<detail::is_utf8_enabled()> {};
|
||||
#endif
|
||||
|
||||
template <typename... T>
|
||||
constexpr auto make_wformat_args(T&... args)
|
||||
-> decltype(fmt::make_format_args<wformat_context>(args...)) {
|
||||
return fmt::make_format_args<wformat_context>(args...);
|
||||
}
|
||||
|
||||
inline namespace literals {
|
||||
#if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_ARGS
|
||||
constexpr auto operator""_a(const wchar_t* s, size_t)
|
||||
-> detail::udl_arg<wchar_t> {
|
||||
return {s};
|
||||
}
|
||||
#endif
|
||||
} // namespace literals
|
||||
|
||||
template <typename It, typename Sentinel>
|
||||
auto join(It begin, Sentinel end, wstring_view sep)
|
||||
-> join_view<It, Sentinel, wchar_t> {
|
||||
return {begin, end, sep};
|
||||
}
|
||||
|
||||
template <typename Range>
|
||||
auto join(Range&& range, wstring_view sep)
|
||||
-> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>,
|
||||
wchar_t> {
|
||||
return join(std::begin(range), std::end(range), sep);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
auto join(std::initializer_list<T> list, wstring_view sep)
|
||||
-> join_view<const T*, const T*, wchar_t> {
|
||||
return join(std::begin(list), std::end(list), sep);
|
||||
}
|
||||
|
||||
template <typename... T>
|
||||
auto join(const std::tuple<T...>& tuple, basic_string_view<wchar_t> sep)
|
||||
-> tuple_join_view<wchar_t, T...> {
|
||||
return {tuple, sep};
|
||||
}
|
||||
|
||||
template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
|
||||
auto vformat(basic_string_view<Char> format_str,
|
||||
typename detail::vformat_args<Char>::type args)
|
||||
-> std::basic_string<Char> {
|
||||
auto buf = basic_memory_buffer<Char>();
|
||||
detail::vformat_to(buf, format_str, args);
|
||||
return to_string(buf);
|
||||
}
|
||||
|
||||
template <typename... T>
|
||||
auto format(wformat_string<T...> fmt, T&&... args) -> std::wstring {
|
||||
return vformat(fmt::wstring_view(fmt), fmt::make_wformat_args(args...));
|
||||
}
|
||||
|
||||
template <typename OutputIt, typename... T>
|
||||
auto format_to(OutputIt out, wformat_string<T...> fmt, T&&... args)
|
||||
-> OutputIt {
|
||||
return vformat_to(out, fmt::wstring_view(fmt),
|
||||
fmt::make_wformat_args(args...));
|
||||
}
|
||||
|
||||
// Pass char_t as a default template parameter instead of using
|
||||
// std::basic_string<char_t<S>> to reduce the symbol size.
|
||||
template <typename S, typename... T,
|
||||
typename Char = detail::format_string_char_t<S>,
|
||||
FMT_ENABLE_IF(!std::is_same<Char, char>::value &&
|
||||
!std::is_same<Char, wchar_t>::value)>
|
||||
auto format(const S& format_str, T&&... args) -> std::basic_string<Char> {
|
||||
return vformat(detail::to_string_view(format_str),
|
||||
fmt::make_format_args<buffered_context<Char>>(args...));
|
||||
}
|
||||
|
||||
template <typename Locale, typename S,
|
||||
typename Char = detail::format_string_char_t<S>,
|
||||
FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
|
||||
detail::is_exotic_char<Char>::value)>
|
||||
inline auto vformat(const Locale& loc, const S& format_str,
|
||||
typename detail::vformat_args<Char>::type args)
|
||||
-> std::basic_string<Char> {
|
||||
return detail::vformat(loc, detail::to_string_view(format_str), args);
|
||||
}
|
||||
|
||||
template <typename Locale, typename S, typename... T,
|
||||
typename Char = detail::format_string_char_t<S>,
|
||||
FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
|
||||
detail::is_exotic_char<Char>::value)>
|
||||
inline auto format(const Locale& loc, const S& format_str, T&&... args)
|
||||
-> std::basic_string<Char> {
|
||||
return detail::vformat(
|
||||
loc, detail::to_string_view(format_str),
|
||||
fmt::make_format_args<buffered_context<Char>>(args...));
|
||||
}
|
||||
|
||||
template <typename OutputIt, typename S,
|
||||
typename Char = detail::format_string_char_t<S>,
|
||||
FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
|
||||
detail::is_exotic_char<Char>::value)>
|
||||
auto vformat_to(OutputIt out, const S& format_str,
|
||||
typename detail::vformat_args<Char>::type args) -> OutputIt {
|
||||
auto&& buf = detail::get_buffer<Char>(out);
|
||||
detail::vformat_to(buf, detail::to_string_view(format_str), args);
|
||||
return detail::get_iterator(buf, out);
|
||||
}
|
||||
|
||||
template <typename OutputIt, typename S, typename... T,
|
||||
typename Char = detail::format_string_char_t<S>,
|
||||
FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value &&
|
||||
!std::is_same<Char, char>::value &&
|
||||
!std::is_same<Char, wchar_t>::value)>
|
||||
inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt {
|
||||
return vformat_to(out, detail::to_string_view(fmt),
|
||||
fmt::make_format_args<buffered_context<Char>>(args...));
|
||||
}
|
||||
|
||||
template <typename Locale, typename S, typename OutputIt, typename... Args,
|
||||
typename Char = detail::format_string_char_t<S>,
|
||||
FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
|
||||
detail::is_locale<Locale>::value&&
|
||||
detail::is_exotic_char<Char>::value)>
|
||||
inline auto vformat_to(OutputIt out, const Locale& loc, const S& format_str,
|
||||
typename detail::vformat_args<Char>::type args)
|
||||
-> OutputIt {
|
||||
auto&& buf = detail::get_buffer<Char>(out);
|
||||
vformat_to(buf, detail::to_string_view(format_str), args,
|
||||
detail::locale_ref(loc));
|
||||
return detail::get_iterator(buf, out);
|
||||
}
|
||||
|
||||
template <typename OutputIt, typename Locale, typename S, typename... T,
|
||||
typename Char = detail::format_string_char_t<S>,
|
||||
bool enable = detail::is_output_iterator<OutputIt, Char>::value &&
|
||||
detail::is_locale<Locale>::value &&
|
||||
detail::is_exotic_char<Char>::value>
|
||||
inline auto format_to(OutputIt out, const Locale& loc, const S& format_str,
|
||||
T&&... args) ->
|
||||
typename std::enable_if<enable, OutputIt>::type {
|
||||
return vformat_to(out, loc, detail::to_string_view(format_str),
|
||||
fmt::make_format_args<buffered_context<Char>>(args...));
|
||||
}
|
||||
|
||||
template <typename OutputIt, typename Char, typename... Args,
|
||||
FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
|
||||
detail::is_exotic_char<Char>::value)>
|
||||
inline auto vformat_to_n(OutputIt out, size_t n,
|
||||
basic_string_view<Char> format_str,
|
||||
typename detail::vformat_args<Char>::type args)
|
||||
-> format_to_n_result<OutputIt> {
|
||||
using traits = detail::fixed_buffer_traits;
|
||||
auto buf = detail::iterator_buffer<OutputIt, Char, traits>(out, n);
|
||||
detail::vformat_to(buf, format_str, args);
|
||||
return {buf.out(), buf.count()};
|
||||
}
|
||||
|
||||
template <typename OutputIt, typename S, typename... T,
|
||||
typename Char = detail::format_string_char_t<S>,
|
||||
FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
|
||||
detail::is_exotic_char<Char>::value)>
|
||||
inline auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args)
|
||||
-> format_to_n_result<OutputIt> {
|
||||
return vformat_to_n(out, n, fmt::basic_string_view<Char>(fmt),
|
||||
fmt::make_format_args<buffered_context<Char>>(args...));
|
||||
}
|
||||
|
||||
template <typename S, typename... T,
|
||||
typename Char = detail::format_string_char_t<S>,
|
||||
FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)>
|
||||
inline auto formatted_size(const S& fmt, T&&... args) -> size_t {
|
||||
auto buf = detail::counting_buffer<Char>();
|
||||
detail::vformat_to(buf, detail::to_string_view(fmt),
|
||||
fmt::make_format_args<buffered_context<Char>>(args...));
|
||||
return buf.count();
|
||||
}
|
||||
|
||||
inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) {
|
||||
auto buf = wmemory_buffer();
|
||||
detail::vformat_to(buf, fmt, args);
|
||||
buf.push_back(L'\0');
|
||||
if (std::fputws(buf.data(), f) == -1)
|
||||
FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
|
||||
}
|
||||
|
||||
inline void vprint(wstring_view fmt, wformat_args args) {
|
||||
vprint(stdout, fmt, args);
|
||||
}
|
||||
|
||||
template <typename... T>
|
||||
void print(std::FILE* f, wformat_string<T...> fmt, T&&... args) {
|
||||
return vprint(f, wstring_view(fmt), fmt::make_wformat_args(args...));
|
||||
}
|
||||
|
||||
template <typename... T> void print(wformat_string<T...> fmt, T&&... args) {
|
||||
return vprint(wstring_view(fmt), fmt::make_wformat_args(args...));
|
||||
}
|
||||
|
||||
template <typename... T>
|
||||
void println(std::FILE* f, wformat_string<T...> fmt, T&&... args) {
|
||||
return print(f, L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
|
||||
}
|
||||
|
||||
template <typename... T> void println(wformat_string<T...> fmt, T&&... args) {
|
||||
return print(L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
|
||||
}
|
||||
|
||||
inline auto vformat(const text_style& ts, wstring_view fmt, wformat_args args)
|
||||
-> std::wstring {
|
||||
auto buf = wmemory_buffer();
|
||||
detail::vformat_to(buf, ts, fmt, args);
|
||||
return fmt::to_string(buf);
|
||||
}
|
||||
|
||||
template <typename... T>
|
||||
inline auto format(const text_style& ts, wformat_string<T...> fmt, T&&... args)
|
||||
-> std::wstring {
|
||||
return fmt::vformat(ts, fmt, fmt::make_wformat_args(args...));
|
||||
}
|
||||
|
||||
template <typename... T>
|
||||
FMT_DEPRECATED void print(std::FILE* f, const text_style& ts,
|
||||
wformat_string<T...> fmt, const T&... args) {
|
||||
vprint(f, ts, fmt, fmt::make_wformat_args(args...));
|
||||
}
|
||||
|
||||
template <typename... T>
|
||||
FMT_DEPRECATED void print(const text_style& ts, wformat_string<T...> fmt,
|
||||
const T&... args) {
|
||||
return print(stdout, ts, fmt, args...);
|
||||
}
|
||||
|
||||
/// Converts `value` to `std::wstring` using the default format for type `T`.
|
||||
template <typename T> inline auto to_wstring(const T& value) -> std::wstring {
|
||||
return format(FMT_STRING(L"{}"), value);
|
||||
}
|
||||
FMT_END_EXPORT
|
||||
FMT_END_NAMESPACE
|
||||
|
||||
#endif // FMT_XCHAR_H_
|
||||
|
|
@ -0,0 +1,135 @@
|
|||
module;
|
||||
|
||||
// Put all implementation-provided headers into the global module fragment
|
||||
// to prevent attachment to this module.
|
||||
#ifndef FMT_IMPORT_STD
|
||||
# include <algorithm>
|
||||
# include <bitset>
|
||||
# include <chrono>
|
||||
# include <cmath>
|
||||
# include <complex>
|
||||
# include <cstddef>
|
||||
# include <cstdint>
|
||||
# include <cstdio>
|
||||
# include <cstdlib>
|
||||
# include <cstring>
|
||||
# include <ctime>
|
||||
# include <exception>
|
||||
# include <expected>
|
||||
# include <filesystem>
|
||||
# include <fstream>
|
||||
# include <functional>
|
||||
# include <iterator>
|
||||
# include <limits>
|
||||
# include <locale>
|
||||
# include <memory>
|
||||
# include <optional>
|
||||
# include <ostream>
|
||||
# include <source_location>
|
||||
# include <stdexcept>
|
||||
# include <string>
|
||||
# include <string_view>
|
||||
# include <system_error>
|
||||
# include <thread>
|
||||
# include <type_traits>
|
||||
# include <typeinfo>
|
||||
# include <utility>
|
||||
# include <variant>
|
||||
# include <vector>
|
||||
#else
|
||||
# include <limits.h>
|
||||
# include <stdint.h>
|
||||
# include <stdio.h>
|
||||
# include <time.h>
|
||||
#endif
|
||||
#include <cerrno>
|
||||
#include <climits>
|
||||
#include <version>
|
||||
|
||||
#if __has_include(<cxxabi.h>)
|
||||
# include <cxxabi.h>
|
||||
#endif
|
||||
#if defined(_MSC_VER) || defined(__MINGW32__)
|
||||
# include <intrin.h>
|
||||
#endif
|
||||
#if defined __APPLE__ || defined(__FreeBSD__)
|
||||
# include <xlocale.h>
|
||||
#endif
|
||||
#if __has_include(<winapifamily.h>)
|
||||
# include <winapifamily.h>
|
||||
#endif
|
||||
#if (__has_include(<fcntl.h>) || defined(__APPLE__) || \
|
||||
defined(__linux__)) && \
|
||||
(!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
|
||||
# include <fcntl.h>
|
||||
# include <sys/stat.h>
|
||||
# include <sys/types.h>
|
||||
# ifndef _WIN32
|
||||
# include <unistd.h>
|
||||
# else
|
||||
# include <io.h>
|
||||
# endif
|
||||
#endif
|
||||
#ifdef _WIN32
|
||||
# if defined(__GLIBCXX__)
|
||||
# include <ext/stdio_filebuf.h>
|
||||
# include <ext/stdio_sync_filebuf.h>
|
||||
# endif
|
||||
# define WIN32_LEAN_AND_MEAN
|
||||
# include <windows.h>
|
||||
#endif
|
||||
|
||||
export module fmt;
|
||||
|
||||
#ifdef FMT_IMPORT_STD
|
||||
import std;
|
||||
#endif
|
||||
|
||||
#define FMT_EXPORT export
|
||||
#define FMT_BEGIN_EXPORT export {
|
||||
#define FMT_END_EXPORT }
|
||||
|
||||
// If you define FMT_ATTACH_TO_GLOBAL_MODULE
|
||||
// - all declarations are detached from module 'fmt'
|
||||
// - the module behaves like a traditional static library, too
|
||||
// - all library symbols are mangled traditionally
|
||||
// - you can mix TUs with either importing or #including the {fmt} API
|
||||
#ifdef FMT_ATTACH_TO_GLOBAL_MODULE
|
||||
extern "C++" {
|
||||
#endif
|
||||
|
||||
#ifndef FMT_OS
|
||||
# define FMT_OS 1
|
||||
#endif
|
||||
|
||||
// All library-provided declarations and definitions must be in the module
|
||||
// purview to be exported.
|
||||
#include "fmt/args.h"
|
||||
#include "fmt/chrono.h"
|
||||
#include "fmt/color.h"
|
||||
#include "fmt/compile.h"
|
||||
#include "fmt/format.h"
|
||||
#if FMT_OS
|
||||
# include "fmt/os.h"
|
||||
#endif
|
||||
#include "fmt/ostream.h"
|
||||
#include "fmt/printf.h"
|
||||
#include "fmt/ranges.h"
|
||||
#include "fmt/std.h"
|
||||
#include "fmt/xchar.h"
|
||||
|
||||
#ifdef FMT_ATTACH_TO_GLOBAL_MODULE
|
||||
}
|
||||
#endif
|
||||
|
||||
// gcc doesn't yet implement private module fragments
|
||||
#if !FMT_GCC_VERSION
|
||||
module :private;
|
||||
#endif
|
||||
|
||||
#if FMT_HAS_INCLUDE("format.cc")
|
||||
# include "format.cc"
|
||||
#endif
|
||||
#if FMT_OS && FMT_HAS_INCLUDE("os.cc")
|
||||
# include "os.cc"
|
||||
#endif
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
// Formatting library for C++
|
||||
//
|
||||
// Copyright (c) 2012 - 2016, Victor Zverovich
|
||||
// All rights reserved.
|
||||
//
|
||||
// For the license information refer to format.h.
|
||||
|
||||
#include "fmt/format-inl.h"
|
||||
|
||||
FMT_BEGIN_NAMESPACE
|
||||
namespace detail {
|
||||
|
||||
template FMT_API auto dragonbox::to_decimal(float x) noexcept
|
||||
-> dragonbox::decimal_fp<float>;
|
||||
template FMT_API auto dragonbox::to_decimal(double x) noexcept
|
||||
-> dragonbox::decimal_fp<double>;
|
||||
|
||||
#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
|
||||
template FMT_API locale_ref::locale_ref(const std::locale& loc);
|
||||
template FMT_API auto locale_ref::get<std::locale>() const -> std::locale;
|
||||
#endif
|
||||
|
||||
// Explicit instantiations for char.
|
||||
|
||||
template FMT_API auto thousands_sep_impl(locale_ref)
|
||||
-> thousands_sep_result<char>;
|
||||
template FMT_API auto decimal_point_impl(locale_ref) -> char;
|
||||
|
||||
template FMT_API void buffer<char>::append(const char*, const char*);
|
||||
|
||||
template FMT_API void vformat_to(buffer<char>&, string_view,
|
||||
typename vformat_args<>::type, locale_ref);
|
||||
|
||||
// Explicit instantiations for wchar_t.
|
||||
|
||||
template FMT_API auto thousands_sep_impl(locale_ref)
|
||||
-> thousands_sep_result<wchar_t>;
|
||||
template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t;
|
||||
|
||||
template FMT_API void buffer<wchar_t>::append(const wchar_t*, const wchar_t*);
|
||||
|
||||
} // namespace detail
|
||||
FMT_END_NAMESPACE
|
||||
|
|
@ -0,0 +1,403 @@
|
|||
// Formatting library for C++ - optional OS-specific functionality
|
||||
//
|
||||
// Copyright (c) 2012 - 2016, Victor Zverovich
|
||||
// All rights reserved.
|
||||
//
|
||||
// For the license information refer to format.h.
|
||||
|
||||
// Disable bogus MSVC warnings.
|
||||
#if !defined(_CRT_SECURE_NO_WARNINGS) && defined(_MSC_VER)
|
||||
# define _CRT_SECURE_NO_WARNINGS
|
||||
#endif
|
||||
|
||||
#include "fmt/os.h"
|
||||
|
||||
#ifndef FMT_MODULE
|
||||
# include <climits>
|
||||
|
||||
# if FMT_USE_FCNTL
|
||||
# include <sys/stat.h>
|
||||
# include <sys/types.h>
|
||||
|
||||
# ifdef _WRS_KERNEL // VxWorks7 kernel
|
||||
# include <ioLib.h> // getpagesize
|
||||
# endif
|
||||
|
||||
# ifndef _WIN32
|
||||
# include <unistd.h>
|
||||
# else
|
||||
# ifndef WIN32_LEAN_AND_MEAN
|
||||
# define WIN32_LEAN_AND_MEAN
|
||||
# endif
|
||||
# include <io.h>
|
||||
# endif // _WIN32
|
||||
# endif // FMT_USE_FCNTL
|
||||
|
||||
# ifdef _WIN32
|
||||
# include <windows.h>
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
# ifndef S_IRUSR
|
||||
# define S_IRUSR _S_IREAD
|
||||
# endif
|
||||
# ifndef S_IWUSR
|
||||
# define S_IWUSR _S_IWRITE
|
||||
# endif
|
||||
# ifndef S_IRGRP
|
||||
# define S_IRGRP 0
|
||||
# endif
|
||||
# ifndef S_IWGRP
|
||||
# define S_IWGRP 0
|
||||
# endif
|
||||
# ifndef S_IROTH
|
||||
# define S_IROTH 0
|
||||
# endif
|
||||
# ifndef S_IWOTH
|
||||
# define S_IWOTH 0
|
||||
# endif
|
||||
#endif
|
||||
|
||||
namespace {
|
||||
#ifdef _WIN32
|
||||
// Return type of read and write functions.
|
||||
using rwresult = int;
|
||||
|
||||
// On Windows the count argument to read and write is unsigned, so convert
|
||||
// it from size_t preventing integer overflow.
|
||||
inline unsigned convert_rwcount(std::size_t count) {
|
||||
return count <= UINT_MAX ? static_cast<unsigned>(count) : UINT_MAX;
|
||||
}
|
||||
#elif FMT_USE_FCNTL
|
||||
// Return type of read and write functions.
|
||||
using rwresult = ssize_t;
|
||||
|
||||
inline std::size_t convert_rwcount(std::size_t count) { return count; }
|
||||
#endif
|
||||
} // namespace
|
||||
|
||||
FMT_BEGIN_NAMESPACE
|
||||
|
||||
#ifdef _WIN32
|
||||
namespace detail {
|
||||
|
||||
class system_message {
|
||||
system_message(const system_message&) = delete;
|
||||
void operator=(const system_message&) = delete;
|
||||
|
||||
unsigned long result_;
|
||||
wchar_t* message_;
|
||||
|
||||
static bool is_whitespace(wchar_t c) noexcept {
|
||||
return c == L' ' || c == L'\n' || c == L'\r' || c == L'\t' || c == L'\0';
|
||||
}
|
||||
|
||||
public:
|
||||
explicit system_message(unsigned long error_code)
|
||||
: result_(0), message_(nullptr) {
|
||||
result_ = FormatMessageW(
|
||||
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
|
||||
FORMAT_MESSAGE_IGNORE_INSERTS,
|
||||
nullptr, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
||||
reinterpret_cast<wchar_t*>(&message_), 0, nullptr);
|
||||
if (result_ != 0) {
|
||||
while (result_ != 0 && is_whitespace(message_[result_ - 1])) {
|
||||
--result_;
|
||||
}
|
||||
}
|
||||
}
|
||||
~system_message() { LocalFree(message_); }
|
||||
explicit operator bool() const noexcept { return result_ != 0; }
|
||||
operator basic_string_view<wchar_t>() const noexcept {
|
||||
return basic_string_view<wchar_t>(message_, result_);
|
||||
}
|
||||
};
|
||||
|
||||
class utf8_system_category final : public std::error_category {
|
||||
public:
|
||||
const char* name() const noexcept override { return "system"; }
|
||||
std::string message(int error_code) const override {
|
||||
auto&& msg = system_message(error_code);
|
||||
if (msg) {
|
||||
auto utf8_message = to_utf8<wchar_t>();
|
||||
if (utf8_message.convert(msg)) {
|
||||
return utf8_message.str();
|
||||
}
|
||||
}
|
||||
return "unknown error";
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
FMT_API const std::error_category& system_category() noexcept {
|
||||
static const detail::utf8_system_category category;
|
||||
return category;
|
||||
}
|
||||
|
||||
std::system_error vwindows_error(int err_code, string_view format_str,
|
||||
format_args args) {
|
||||
auto ec = std::error_code(err_code, system_category());
|
||||
return std::system_error(ec, vformat(format_str, args));
|
||||
}
|
||||
|
||||
void detail::format_windows_error(detail::buffer<char>& out, int error_code,
|
||||
const char* message) noexcept {
|
||||
FMT_TRY {
|
||||
auto&& msg = system_message(error_code);
|
||||
if (msg) {
|
||||
auto utf8_message = to_utf8<wchar_t>();
|
||||
if (utf8_message.convert(msg)) {
|
||||
fmt::format_to(appender(out), FMT_STRING("{}: {}"), message,
|
||||
string_view(utf8_message));
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
FMT_CATCH(...) {}
|
||||
format_error_code(out, error_code, message);
|
||||
}
|
||||
|
||||
void report_windows_error(int error_code, const char* message) noexcept {
|
||||
report_error(detail::format_windows_error, error_code, message);
|
||||
}
|
||||
#endif // _WIN32
|
||||
|
||||
buffered_file::~buffered_file() noexcept {
|
||||
if (file_ && FMT_SYSTEM(fclose(file_)) != 0)
|
||||
report_system_error(errno, "cannot close file");
|
||||
}
|
||||
|
||||
buffered_file::buffered_file(cstring_view filename, cstring_view mode) {
|
||||
FMT_RETRY_VAL(file_, FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())),
|
||||
nullptr);
|
||||
if (!file_)
|
||||
FMT_THROW(system_error(errno, FMT_STRING("cannot open file {}"),
|
||||
filename.c_str()));
|
||||
}
|
||||
|
||||
void buffered_file::close() {
|
||||
if (!file_) return;
|
||||
int result = FMT_SYSTEM(fclose(file_));
|
||||
file_ = nullptr;
|
||||
if (result != 0)
|
||||
FMT_THROW(system_error(errno, FMT_STRING("cannot close file")));
|
||||
}
|
||||
|
||||
int buffered_file::descriptor() const {
|
||||
#ifdef FMT_HAS_SYSTEM
|
||||
// fileno is a macro on OpenBSD.
|
||||
# ifdef fileno
|
||||
# undef fileno
|
||||
# endif
|
||||
int fd = FMT_POSIX_CALL(fileno(file_));
|
||||
#elif defined(_WIN32)
|
||||
int fd = _fileno(file_);
|
||||
#else
|
||||
int fd = fileno(file_);
|
||||
#endif
|
||||
if (fd == -1)
|
||||
FMT_THROW(system_error(errno, FMT_STRING("cannot get file descriptor")));
|
||||
return fd;
|
||||
}
|
||||
|
||||
#if FMT_USE_FCNTL
|
||||
# ifdef _WIN32
|
||||
using mode_t = int;
|
||||
# endif
|
||||
|
||||
constexpr mode_t default_open_mode =
|
||||
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
|
||||
|
||||
file::file(cstring_view path, int oflag) {
|
||||
# if defined(_WIN32) && !defined(__MINGW32__)
|
||||
fd_ = -1;
|
||||
auto converted = detail::utf8_to_utf16(string_view(path.c_str()));
|
||||
*this = file::open_windows_file(converted.c_str(), oflag);
|
||||
# else
|
||||
FMT_RETRY(fd_, FMT_POSIX_CALL(open(path.c_str(), oflag, default_open_mode)));
|
||||
if (fd_ == -1)
|
||||
FMT_THROW(
|
||||
system_error(errno, FMT_STRING("cannot open file {}"), path.c_str()));
|
||||
# endif
|
||||
}
|
||||
|
||||
file::~file() noexcept {
|
||||
// Don't retry close in case of EINTR!
|
||||
// See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
|
||||
if (fd_ != -1 && FMT_POSIX_CALL(close(fd_)) != 0)
|
||||
report_system_error(errno, "cannot close file");
|
||||
}
|
||||
|
||||
void file::close() {
|
||||
if (fd_ == -1) return;
|
||||
// Don't retry close in case of EINTR!
|
||||
// See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
|
||||
int result = FMT_POSIX_CALL(close(fd_));
|
||||
fd_ = -1;
|
||||
if (result != 0)
|
||||
FMT_THROW(system_error(errno, FMT_STRING("cannot close file")));
|
||||
}
|
||||
|
||||
long long file::size() const {
|
||||
# ifdef _WIN32
|
||||
// Use GetFileSize instead of GetFileSizeEx for the case when _WIN32_WINNT
|
||||
// is less than 0x0500 as is the case with some default MinGW builds.
|
||||
// Both functions support large file sizes.
|
||||
DWORD size_upper = 0;
|
||||
HANDLE handle = reinterpret_cast<HANDLE>(_get_osfhandle(fd_));
|
||||
DWORD size_lower = FMT_SYSTEM(GetFileSize(handle, &size_upper));
|
||||
if (size_lower == INVALID_FILE_SIZE) {
|
||||
DWORD error = GetLastError();
|
||||
if (error != NO_ERROR)
|
||||
FMT_THROW(windows_error(GetLastError(), "cannot get file size"));
|
||||
}
|
||||
unsigned long long long_size = size_upper;
|
||||
return (long_size << sizeof(DWORD) * CHAR_BIT) | size_lower;
|
||||
# else
|
||||
using Stat = struct stat;
|
||||
Stat file_stat = Stat();
|
||||
if (FMT_POSIX_CALL(fstat(fd_, &file_stat)) == -1)
|
||||
FMT_THROW(system_error(errno, FMT_STRING("cannot get file attributes")));
|
||||
static_assert(sizeof(long long) >= sizeof(file_stat.st_size),
|
||||
"return type of file::size is not large enough");
|
||||
return file_stat.st_size;
|
||||
# endif
|
||||
}
|
||||
|
||||
std::size_t file::read(void* buffer, std::size_t count) {
|
||||
rwresult result = 0;
|
||||
FMT_RETRY(result, FMT_POSIX_CALL(read(fd_, buffer, convert_rwcount(count))));
|
||||
if (result < 0)
|
||||
FMT_THROW(system_error(errno, FMT_STRING("cannot read from file")));
|
||||
return detail::to_unsigned(result);
|
||||
}
|
||||
|
||||
std::size_t file::write(const void* buffer, std::size_t count) {
|
||||
rwresult result = 0;
|
||||
FMT_RETRY(result, FMT_POSIX_CALL(write(fd_, buffer, convert_rwcount(count))));
|
||||
if (result < 0)
|
||||
FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
|
||||
return detail::to_unsigned(result);
|
||||
}
|
||||
|
||||
file file::dup(int fd) {
|
||||
// Don't retry as dup doesn't return EINTR.
|
||||
// http://pubs.opengroup.org/onlinepubs/009695399/functions/dup.html
|
||||
int new_fd = FMT_POSIX_CALL(dup(fd));
|
||||
if (new_fd == -1)
|
||||
FMT_THROW(system_error(
|
||||
errno, FMT_STRING("cannot duplicate file descriptor {}"), fd));
|
||||
return file(new_fd);
|
||||
}
|
||||
|
||||
void file::dup2(int fd) {
|
||||
int result = 0;
|
||||
FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
|
||||
if (result == -1) {
|
||||
FMT_THROW(system_error(
|
||||
errno, FMT_STRING("cannot duplicate file descriptor {} to {}"), fd_,
|
||||
fd));
|
||||
}
|
||||
}
|
||||
|
||||
void file::dup2(int fd, std::error_code& ec) noexcept {
|
||||
int result = 0;
|
||||
FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
|
||||
if (result == -1) ec = std::error_code(errno, std::generic_category());
|
||||
}
|
||||
|
||||
buffered_file file::fdopen(const char* mode) {
|
||||
// Don't retry as fdopen doesn't return EINTR.
|
||||
# if defined(__MINGW32__) && defined(_POSIX_)
|
||||
FILE* f = ::fdopen(fd_, mode);
|
||||
# else
|
||||
FILE* f = FMT_POSIX_CALL(fdopen(fd_, mode));
|
||||
# endif
|
||||
if (!f) {
|
||||
FMT_THROW(system_error(
|
||||
errno, FMT_STRING("cannot associate stream with file descriptor")));
|
||||
}
|
||||
buffered_file bf(f);
|
||||
fd_ = -1;
|
||||
return bf;
|
||||
}
|
||||
|
||||
# if defined(_WIN32) && !defined(__MINGW32__)
|
||||
file file::open_windows_file(wcstring_view path, int oflag) {
|
||||
int fd = -1;
|
||||
auto err = _wsopen_s(&fd, path.c_str(), oflag, _SH_DENYNO, default_open_mode);
|
||||
if (fd == -1) {
|
||||
FMT_THROW(system_error(err, FMT_STRING("cannot open file {}"),
|
||||
detail::to_utf8<wchar_t>(path.c_str()).c_str()));
|
||||
}
|
||||
return file(fd);
|
||||
}
|
||||
# endif
|
||||
|
||||
pipe::pipe() {
|
||||
int fds[2] = {};
|
||||
# ifdef _WIN32
|
||||
// Make the default pipe capacity same as on Linux 2.6.11+.
|
||||
enum { DEFAULT_CAPACITY = 65536 };
|
||||
int result = FMT_POSIX_CALL(pipe(fds, DEFAULT_CAPACITY, _O_BINARY));
|
||||
# else
|
||||
// Don't retry as the pipe function doesn't return EINTR.
|
||||
// http://pubs.opengroup.org/onlinepubs/009696799/functions/pipe.html
|
||||
int result = FMT_POSIX_CALL(pipe(fds));
|
||||
# endif
|
||||
if (result != 0)
|
||||
FMT_THROW(system_error(errno, FMT_STRING("cannot create pipe")));
|
||||
// The following assignments don't throw.
|
||||
read_end = file(fds[0]);
|
||||
write_end = file(fds[1]);
|
||||
}
|
||||
|
||||
# if !defined(__MSDOS__)
|
||||
long getpagesize() {
|
||||
# ifdef _WIN32
|
||||
SYSTEM_INFO si;
|
||||
GetSystemInfo(&si);
|
||||
return si.dwPageSize;
|
||||
# else
|
||||
# ifdef _WRS_KERNEL
|
||||
long size = FMT_POSIX_CALL(getpagesize());
|
||||
# else
|
||||
long size = FMT_POSIX_CALL(sysconf(_SC_PAGESIZE));
|
||||
# endif
|
||||
|
||||
if (size < 0)
|
||||
FMT_THROW(system_error(errno, FMT_STRING("cannot get memory page size")));
|
||||
return size;
|
||||
# endif
|
||||
}
|
||||
# endif
|
||||
|
||||
namespace detail {
|
||||
|
||||
void file_buffer::grow(buffer<char>& buf, size_t) {
|
||||
if (buf.size() == buf.capacity()) static_cast<file_buffer&>(buf).flush();
|
||||
}
|
||||
|
||||
file_buffer::file_buffer(cstring_view path, const ostream_params& params)
|
||||
: buffer<char>(grow), file_(path, params.oflag) {
|
||||
set(new char[params.buffer_size], params.buffer_size);
|
||||
}
|
||||
|
||||
file_buffer::file_buffer(file_buffer&& other) noexcept
|
||||
: buffer<char>(grow, other.data(), other.size(), other.capacity()),
|
||||
file_(std::move(other.file_)) {
|
||||
other.clear();
|
||||
other.set(nullptr, 0);
|
||||
}
|
||||
|
||||
file_buffer::~file_buffer() {
|
||||
flush();
|
||||
delete[] data();
|
||||
}
|
||||
} // namespace detail
|
||||
|
||||
ostream::~ostream() = default;
|
||||
#endif // FMT_USE_FCNTL
|
||||
FMT_END_NAMESPACE
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,176 @@
|
|||
// __ _____ _____ _____
|
||||
// __| | __| | | | JSON for Modern C++
|
||||
// | | |__ | | | | | | version 3.11.3
|
||||
// |_____|_____|_____|_|___| https://github.com/nlohmann/json
|
||||
//
|
||||
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
|
||||
#define INCLUDE_NLOHMANN_JSON_FWD_HPP_
|
||||
|
||||
#include <cstdint> // int64_t, uint64_t
|
||||
#include <map> // map
|
||||
#include <memory> // allocator
|
||||
#include <string> // string
|
||||
#include <vector> // vector
|
||||
|
||||
// #include <nlohmann/detail/abi_macros.hpp>
|
||||
// __ _____ _____ _____
|
||||
// __| | __| | | | JSON for Modern C++
|
||||
// | | |__ | | | | | | version 3.11.3
|
||||
// |_____|_____|_____|_|___| https://github.com/nlohmann/json
|
||||
//
|
||||
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
|
||||
|
||||
// This file contains all macro definitions affecting or depending on the ABI
|
||||
|
||||
#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK
|
||||
#if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH)
|
||||
#if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 11 || NLOHMANN_JSON_VERSION_PATCH != 3
|
||||
#warning "Already included a different version of the library!"
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#define NLOHMANN_JSON_VERSION_MAJOR 3 // NOLINT(modernize-macro-to-enum)
|
||||
#define NLOHMANN_JSON_VERSION_MINOR 11 // NOLINT(modernize-macro-to-enum)
|
||||
#define NLOHMANN_JSON_VERSION_PATCH 3 // NOLINT(modernize-macro-to-enum)
|
||||
|
||||
#ifndef JSON_DIAGNOSTICS
|
||||
#define JSON_DIAGNOSTICS 0
|
||||
#endif
|
||||
|
||||
#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
|
||||
#define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0
|
||||
#endif
|
||||
|
||||
#if JSON_DIAGNOSTICS
|
||||
#define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
|
||||
#else
|
||||
#define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS
|
||||
#endif
|
||||
|
||||
#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
|
||||
#define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp
|
||||
#else
|
||||
#define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON
|
||||
#endif
|
||||
|
||||
#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
|
||||
#define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
|
||||
#endif
|
||||
|
||||
// Construct the namespace ABI tags component
|
||||
#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) json_abi ## a ## b
|
||||
#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b) \
|
||||
NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b)
|
||||
|
||||
#define NLOHMANN_JSON_ABI_TAGS \
|
||||
NLOHMANN_JSON_ABI_TAGS_CONCAT( \
|
||||
NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS, \
|
||||
NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)
|
||||
|
||||
// Construct the namespace version component
|
||||
#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
|
||||
_v ## major ## _ ## minor ## _ ## patch
|
||||
#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \
|
||||
NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)
|
||||
|
||||
#if NLOHMANN_JSON_NAMESPACE_NO_VERSION
|
||||
#define NLOHMANN_JSON_NAMESPACE_VERSION
|
||||
#else
|
||||
#define NLOHMANN_JSON_NAMESPACE_VERSION \
|
||||
NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \
|
||||
NLOHMANN_JSON_VERSION_MINOR, \
|
||||
NLOHMANN_JSON_VERSION_PATCH)
|
||||
#endif
|
||||
|
||||
// Combine namespace components
|
||||
#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b
|
||||
#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \
|
||||
NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b)
|
||||
|
||||
#ifndef NLOHMANN_JSON_NAMESPACE
|
||||
#define NLOHMANN_JSON_NAMESPACE \
|
||||
nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \
|
||||
NLOHMANN_JSON_ABI_TAGS, \
|
||||
NLOHMANN_JSON_NAMESPACE_VERSION)
|
||||
#endif
|
||||
|
||||
#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN
|
||||
#define NLOHMANN_JSON_NAMESPACE_BEGIN \
|
||||
namespace nlohmann \
|
||||
{ \
|
||||
inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \
|
||||
NLOHMANN_JSON_ABI_TAGS, \
|
||||
NLOHMANN_JSON_NAMESPACE_VERSION) \
|
||||
{
|
||||
#endif
|
||||
|
||||
#ifndef NLOHMANN_JSON_NAMESPACE_END
|
||||
#define NLOHMANN_JSON_NAMESPACE_END \
|
||||
} /* namespace (inline namespace) NOLINT(readability/namespace) */ \
|
||||
} // namespace nlohmann
|
||||
#endif
|
||||
|
||||
|
||||
/*!
|
||||
@brief namespace for Niels Lohmann
|
||||
@see https://github.com/nlohmann
|
||||
@since version 1.0.0
|
||||
*/
|
||||
NLOHMANN_JSON_NAMESPACE_BEGIN
|
||||
|
||||
/*!
|
||||
@brief default JSONSerializer template argument
|
||||
|
||||
This serializer ignores the template arguments and uses ADL
|
||||
([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
|
||||
for serialization.
|
||||
*/
|
||||
template<typename T = void, typename SFINAE = void>
|
||||
struct adl_serializer;
|
||||
|
||||
/// a class to store JSON values
|
||||
/// @sa https://json.nlohmann.me/api/basic_json/
|
||||
template<template<typename U, typename V, typename... Args> class ObjectType =
|
||||
std::map,
|
||||
template<typename U, typename... Args> class ArrayType = std::vector,
|
||||
class StringType = std::string, class BooleanType = bool,
|
||||
class NumberIntegerType = std::int64_t,
|
||||
class NumberUnsignedType = std::uint64_t,
|
||||
class NumberFloatType = double,
|
||||
template<typename U> class AllocatorType = std::allocator,
|
||||
template<typename T, typename SFINAE = void> class JSONSerializer =
|
||||
adl_serializer,
|
||||
class BinaryType = std::vector<std::uint8_t>, // cppcheck-suppress syntaxError
|
||||
class CustomBaseClass = void>
|
||||
class basic_json;
|
||||
|
||||
/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
|
||||
/// @sa https://json.nlohmann.me/api/json_pointer/
|
||||
template<typename RefStringType>
|
||||
class json_pointer;
|
||||
|
||||
/*!
|
||||
@brief default specialization
|
||||
@sa https://json.nlohmann.me/api/json/
|
||||
*/
|
||||
using json = basic_json<>;
|
||||
|
||||
/// @brief a minimal map-like container that preserves insertion order
|
||||
/// @sa https://json.nlohmann.me/api/ordered_map/
|
||||
template<class Key, class T, class IgnoredLess, class Allocator>
|
||||
struct ordered_map;
|
||||
|
||||
/// @brief specialization that maintains the insertion order of object keys
|
||||
/// @sa https://json.nlohmann.me/api/ordered_json/
|
||||
using ordered_json = basic_json<nlohmann::ordered_map>;
|
||||
|
||||
NLOHMANN_JSON_NAMESPACE_END
|
||||
|
||||
#endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_
|
||||
|
|
@ -0,0 +1,503 @@
|
|||
#include "Il2cppJson.hpp"
|
||||
#include <nlohmann/json.hpp>
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
|
||||
#include "../GakumasLocalify/Log.h"
|
||||
#include "../GakumasLocalify/Plugin.h"
|
||||
|
||||
namespace Il2cppJson {
|
||||
// static ClassMap s_classMap{};
|
||||
static bool s_initialized = false;
|
||||
|
||||
ClassMap& GetClassMap() {
|
||||
// 这里的静态变量只有在第一次调用 GetClassMap() 时才会被初始化，完美避开顺序问题
|
||||
static ClassMap s_classMap;
|
||||
return s_classMap;
|
||||
}
|
||||
|
||||
// ─── helpers ────────────────────────────────────────────────────────
|
||||
|
||||
static std::string trim(const std::string& s) {
|
||||
auto start = s.find_first_not_of(" \t\r\n");
|
||||
if (start == std::string::npos) return "";
|
||||
auto end = s.find_last_not_of(" \t\r\n");
|
||||
return s.substr(start, end - start + 1);
|
||||
}
|
||||
|
||||
/// Parse `group` field into assembly / namespace / class.
|
||||
/// "Assembly-CSharp.dll/Campus/OutGame/SomePresenter"
|
||||
/// → assembly = "Assembly-CSharp.dll"
|
||||
/// → nameSpace = "Campus.OutGame"
|
||||
/// → className = "SomePresenter"
|
||||
static bool parseGroup(const std::string& group,
|
||||
std::string& assembly,
|
||||
std::string& nameSpace,
|
||||
std::string& className) {
|
||||
auto dllPos = group.find(".dll");
|
||||
if (dllPos == std::string::npos) return false;
|
||||
assembly = group.substr(0, dllPos + 4);
|
||||
|
||||
size_t restStart = dllPos + 4;
|
||||
if (restStart < group.size() && group[restStart] == '/')
|
||||
restStart++;
|
||||
if (restStart >= group.size()) return false;
|
||||
|
||||
std::string rest = group.substr(restStart);
|
||||
|
||||
std::vector<std::string> parts;
|
||||
size_t pos = 0;
|
||||
while (pos < rest.size()) {
|
||||
auto next = rest.find('/', pos);
|
||||
if (next == std::string::npos) {
|
||||
parts.push_back(rest.substr(pos));
|
||||
break;
|
||||
}
|
||||
parts.push_back(rest.substr(pos, next - pos));
|
||||
pos = next + 1;
|
||||
}
|
||||
if (parts.empty()) return false;
|
||||
|
||||
className = parts.back();
|
||||
parts.pop_back();
|
||||
|
||||
nameSpace.clear();
|
||||
for (size_t i = 0; i < parts.size(); i++) {
|
||||
if (i > 0) nameSpace += '.';
|
||||
nameSpace += parts[i];
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/// Bracket-aware split of a parameter list string by comma.
|
||||
/// "IReadOnlyList`1[A,B], Int32" → ["IReadOnlyList`1[A,B]", "Int32"]
|
||||
static std::vector<std::string> splitParams(const std::string& paramStr) {
|
||||
std::vector<std::string> result;
|
||||
if (paramStr.empty()) return result;
|
||||
|
||||
int depth = 0;
|
||||
std::string current;
|
||||
|
||||
for (char c : paramStr) {
|
||||
if (c == '[' || c == '<' || c == '(') {
|
||||
depth++;
|
||||
current += c;
|
||||
} else if (c == ']' || c == '>' || c == ')') {
|
||||
depth--;
|
||||
current += c;
|
||||
} else if (c == ',' && depth == 0) {
|
||||
auto t = trim(current);
|
||||
if (!t.empty()) result.push_back(t);
|
||||
current.clear();
|
||||
} else {
|
||||
current += c;
|
||||
}
|
||||
}
|
||||
|
||||
auto t = trim(current);
|
||||
if (!t.empty()) result.push_back(t);
|
||||
return result;
|
||||
}
|
||||
|
||||
/// Parse `dotNetSignature` into method name and parameter type list.
|
||||
/// "Void SetItemModels(IReadOnlyList`1[X])"
|
||||
/// → methodName = "SetItemModels", paramTypes = ["IReadOnlyList`1[X]"]
|
||||
///
|
||||
/// "EmbeddedAttribute()"
|
||||
/// → methodName = "EmbeddedAttribute", paramTypes = []
|
||||
static bool parseDotNetSignature(const std::string& sig,
|
||||
std::string& methodName,
|
||||
std::vector<std::string>& paramTypes) {
|
||||
auto parenOpen = sig.find('(');
|
||||
if (parenOpen == std::string::npos) return false;
|
||||
|
||||
std::string prefix = sig.substr(0, parenOpen);
|
||||
auto lastSpace = prefix.rfind(' ');
|
||||
methodName = (lastSpace != std::string::npos)
|
||||
? prefix.substr(lastSpace + 1)
|
||||
: prefix;
|
||||
|
||||
if (methodName.empty()) return false;
|
||||
|
||||
auto parenClose = sig.rfind(')');
|
||||
if (parenClose == std::string::npos || parenClose <= parenOpen) {
|
||||
paramTypes.clear();
|
||||
return true;
|
||||
}
|
||||
|
||||
std::string paramStr = trim(sig.substr(parenOpen + 1,
|
||||
parenClose - parenOpen - 1));
|
||||
paramTypes = splitParams(paramStr);
|
||||
return true;
|
||||
}
|
||||
|
||||
static uintptr_t parseHexAddress(const std::string& hexStr) {
|
||||
try {
|
||||
return std::stoull(hexStr, nullptr, 16);
|
||||
} catch (...) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/// Match a stored param type against a queried type name.
|
||||
/// Supports short name matching: stored "System.Int32" matches query "Int32".
|
||||
static bool typeMatches(const std::string& stored, const std::string& query) {
|
||||
if (query == "*") return true;
|
||||
if (stored == query) return true;
|
||||
|
||||
auto dotPos = stored.rfind('.');
|
||||
if (dotPos != std::string::npos && stored.substr(dotPos + 1) == query)
|
||||
return true;
|
||||
|
||||
dotPos = query.rfind('.');
|
||||
if (dotPos != std::string::npos && query.substr(dotPos + 1) == stored)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
// ─── Class::GetMethod ───────────────────────────────────────────────
|
||||
|
||||
Method* Class::GetMethod(const std::string& methodName,
|
||||
const std::vector<std::string>& args) {
|
||||
auto it = methods.find(methodName);
|
||||
if (it == methods.end()) return nullptr;
|
||||
auto& overloads = it->second;
|
||||
|
||||
if (args.empty()) {
|
||||
return overloads.empty() ? nullptr : &overloads[0];
|
||||
}
|
||||
|
||||
// exact type match
|
||||
for (auto& m : overloads) {
|
||||
if (m.paramCount != static_cast<int>(args.size())) continue;
|
||||
bool match = true;
|
||||
for (int i = 0; i < m.paramCount; i++) {
|
||||
if (!typeMatches(m.paramTypes[i], args[i])) {
|
||||
match = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (match) return &m;
|
||||
}
|
||||
|
||||
// fallback: match by param count only
|
||||
for (auto& m : overloads) {
|
||||
if (m.paramCount == static_cast<int>(args.size()))
|
||||
return &m;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
std::filesystem::path GetBasePath() {
|
||||
return GakumasLocal::Plugin::GetInstance().GetHookInstaller()->localizationFilesDir;
|
||||
}
|
||||
|
||||
// ─── Flat binary format structs ─────────────────────────────────────
|
||||
//
|
||||
// Matches the output of convert_il2cpp_json_to_bin.py.
|
||||
// All string parsing (parseGroup, parseDotNetSignature) is done offline
|
||||
// by the Python script; the binary contains pre-processed data.
|
||||
|
||||
#pragma pack(push, 1)
|
||||
struct BinHeader {
|
||||
char magic[4]; // "ILCB"
|
||||
uint32_t version; // 1
|
||||
uint32_t methodCount;
|
||||
uint32_t totalParamCount;
|
||||
};
|
||||
|
||||
struct BinMethodEntry {
|
||||
uint32_t assemblyOff, assemblyLen;
|
||||
uint32_t namespaceOff, namespaceLen;
|
||||
uint32_t classnameOff, classnameLen;
|
||||
uint32_t methodnameOff, methodnameLen;
|
||||
uint32_t paramCount;
|
||||
uint32_t paramsStartIdx;
|
||||
uint64_t rva;
|
||||
};
|
||||
|
||||
struct BinParamRef {
|
||||
uint32_t strOff;
|
||||
uint32_t strLen;
|
||||
};
|
||||
#pragma pack(pop)
|
||||
|
||||
// ─── Public API ─────────────────────────────────────────────────────
|
||||
|
||||
void LoadIl2cppAddress()
|
||||
{
|
||||
const std::string path = (GetBasePath() / "il2cpp_map.json").string();
|
||||
|
||||
std::ifstream file(path);
|
||||
if (!file.is_open()) return;
|
||||
|
||||
nlohmann::json root;
|
||||
try {
|
||||
root = nlohmann::json::parse(file);
|
||||
} catch (const std::exception&) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!root.is_object()) return;
|
||||
|
||||
for (auto& [name, value] : root.items()) {
|
||||
uintptr_t addr = 0;
|
||||
if (value.is_number_unsigned()) {
|
||||
addr = value.get<uintptr_t>();
|
||||
} else if (value.is_string()) {
|
||||
addr = parseHexAddress(value.get<std::string>());
|
||||
} else if (value.is_number_integer()) {
|
||||
addr = static_cast<uintptr_t>(value.get<int64_t>());
|
||||
}
|
||||
if (addr != 0) {
|
||||
GetIl2cppAddressMap()[name] = addr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static bool InitFromBin(const std::string& path, uintptr_t baseAddress) {
|
||||
std::ifstream file(path, std::ios::binary | std::ios::ate);
|
||||
if (!file.is_open()) return false;
|
||||
|
||||
auto fileSize = static_cast<size_t>(file.tellg());
|
||||
if (fileSize < sizeof(BinHeader)) return false;
|
||||
|
||||
file.seekg(0);
|
||||
std::vector<char> buf(fileSize);
|
||||
file.read(buf.data(), static_cast<std::streamsize>(fileSize));
|
||||
if (!file) return false;
|
||||
|
||||
const char* data = buf.data();
|
||||
const auto* header = reinterpret_cast<const BinHeader*>(data);
|
||||
|
||||
if (std::memcmp(header->magic, "ILCB", 4) != 0 || header->version != 1) {
|
||||
GakumasLocal::Log::Error("Il2cppJson::InitFromBin: invalid header");
|
||||
return false;
|
||||
}
|
||||
|
||||
size_t methodsOffset = sizeof(BinHeader);
|
||||
size_t paramsOffset = methodsOffset + header->methodCount * sizeof(BinMethodEntry);
|
||||
size_t stringsOffset = paramsOffset + header->totalParamCount * sizeof(BinParamRef);
|
||||
|
||||
if (stringsOffset > fileSize) {
|
||||
GakumasLocal::Log::Error("Il2cppJson::InitFromBin: file truncated");
|
||||
return false;
|
||||
}
|
||||
|
||||
const auto* methods = reinterpret_cast<const BinMethodEntry*>(data + methodsOffset);
|
||||
const auto* params = reinterpret_cast<const BinParamRef*>(data + paramsOffset);
|
||||
const char* strings = data + stringsOffset;
|
||||
size_t stringsSize = fileSize - stringsOffset;
|
||||
|
||||
auto getString = [&](uint32_t off, uint32_t len) -> std::string {
|
||||
if (off + len > stringsSize) return "";
|
||||
return {strings + off, len};
|
||||
};
|
||||
|
||||
int parsedCount = 0;
|
||||
|
||||
for (uint32_t i = 0; i < header->methodCount; i++) {
|
||||
const auto& me = methods[i];
|
||||
|
||||
std::string assembly = getString(me.assemblyOff, me.assemblyLen);
|
||||
std::string nameSpace = getString(me.namespaceOff, me.namespaceLen);
|
||||
std::string clsName = getString(me.classnameOff, me.classnameLen);
|
||||
std::string methName = getString(me.methodnameOff, me.methodnameLen);
|
||||
|
||||
uintptr_t execAddr = baseAddress + static_cast<uintptr_t>(me.rva);
|
||||
|
||||
Class& cls = GetClassMap()[assembly][nameSpace][clsName];
|
||||
if (cls.assemblyName.empty()) {
|
||||
cls.assemblyName = assembly;
|
||||
cls.namespaceName = nameSpace;
|
||||
cls.className = clsName;
|
||||
}
|
||||
|
||||
Method method;
|
||||
method.name = methName;
|
||||
method.paramCount = static_cast<int>(me.paramCount);
|
||||
method.address = execAddr;
|
||||
|
||||
method.paramTypes.reserve(me.paramCount);
|
||||
for (uint32_t j = 0; j < me.paramCount; j++) {
|
||||
const auto& pr = params[me.paramsStartIdx + j];
|
||||
method.paramTypes.push_back(getString(pr.strOff, pr.strLen));
|
||||
}
|
||||
|
||||
cls.methods[methName].push_back(std::move(method));
|
||||
parsedCount++;
|
||||
}
|
||||
|
||||
s_initialized = true;
|
||||
GakumasLocal::Log::InfoFmt(
|
||||
"Il2cppJson::InitFromBin: loaded %d methods from %s",
|
||||
parsedCount, path.c_str());
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool InitFromJson(uintptr_t baseAddress) {
|
||||
const std::string path = GetBasePath() / "il2cpp.json";
|
||||
if (path.empty()) {
|
||||
GakumasLocal::Log::Error("Il2cppJson::InitFromJson: cannot determine JSON path");
|
||||
return false;
|
||||
}
|
||||
|
||||
GakumasLocal::Log::InfoFmt("Il2cppJson::InitFromJson: loading %s (base=0x%lx)",
|
||||
path.c_str(), static_cast<unsigned long>(GetUnityBaseAddress()));
|
||||
|
||||
std::ifstream file(path);
|
||||
if (!file.is_open()) {
|
||||
GakumasLocal::Log::ErrorFmt("Il2cppJson::InitFromJson: cannot open %s", path.c_str());
|
||||
return false;
|
||||
}
|
||||
|
||||
nlohmann::json root;
|
||||
try {
|
||||
root = nlohmann::json::parse(file);
|
||||
} catch (const std::exception& e) {
|
||||
GakumasLocal::Log::ErrorFmt("Il2cppJson::InitFromJson: JSON parse error: %s", e.what());
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!root.contains("addressMap") ||
|
||||
!root["addressMap"].contains("methodDefinitions")) {
|
||||
GakumasLocal::Log::Error("Il2cppJson::InitFromJson: missing addressMap.methodDefinitions");
|
||||
return false;
|
||||
}
|
||||
|
||||
const auto& defs = root["addressMap"]["methodDefinitions"];
|
||||
int parsedCount = 0;
|
||||
int errorCount = 0;
|
||||
|
||||
for (const auto& entry : defs) {
|
||||
if (!entry.contains("group") ||
|
||||
!entry.contains("dotNetSignature") ||
|
||||
!entry.contains("virtualAddress")) {
|
||||
errorCount++;
|
||||
continue;
|
||||
}
|
||||
|
||||
std::string group = entry["group"].get<std::string>();
|
||||
std::string dotNetSig = entry["dotNetSignature"].get<std::string>();
|
||||
std::string vaStr = entry["virtualAddress"].get<std::string>();
|
||||
|
||||
std::string assembly, nameSpace, clsName;
|
||||
if (!parseGroup(group, assembly, nameSpace, clsName)) {
|
||||
errorCount++;
|
||||
continue;
|
||||
}
|
||||
|
||||
std::string methodName;
|
||||
std::vector<std::string> paramTypes;
|
||||
if (!parseDotNetSignature(dotNetSig, methodName, paramTypes)) {
|
||||
errorCount++;
|
||||
continue;
|
||||
}
|
||||
|
||||
uintptr_t rva = parseHexAddress(vaStr);
|
||||
uintptr_t execAddr = GetUnityBaseAddress() + rva;
|
||||
|
||||
Class& cls = GetClassMap()[assembly][nameSpace][clsName];
|
||||
if (cls.assemblyName.empty()) {
|
||||
cls.assemblyName = assembly;
|
||||
cls.namespaceName = nameSpace;
|
||||
cls.className = clsName;
|
||||
}
|
||||
|
||||
Method method;
|
||||
method.name = methodName;
|
||||
method.paramTypes = std::move(paramTypes);
|
||||
method.paramCount = static_cast<int>(method.paramTypes.size());
|
||||
method.address = execAddr;
|
||||
|
||||
cls.methods[methodName].push_back(std::move(method));
|
||||
parsedCount++;
|
||||
}
|
||||
|
||||
s_initialized = true;
|
||||
GakumasLocal::Log::InfoFmt(
|
||||
"Il2cppJson::InitFromJson: parsed %d methods (%d skipped) from %s",
|
||||
parsedCount, errorCount, path.c_str());
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Init(uintptr_t baseAddress) {
|
||||
if (s_initialized) return true;
|
||||
|
||||
GetUnityBaseAddress() = baseAddress;
|
||||
GakumasLocal::Log::InfoFmt("Set s_baseAddress to %p, now: %p",
|
||||
(void*)baseAddress, (void*)GetUnityBaseAddress());
|
||||
|
||||
LoadIl2cppAddress();
|
||||
|
||||
const std::string binPath = (GetBasePath() / "il2cpp.bin").string();
|
||||
if (InitFromBin(binPath, baseAddress)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
GakumasLocal::Log::Info("Il2cppJson::Init: .bin not found or invalid");
|
||||
return false;
|
||||
// return InitFromJson(baseAddress);
|
||||
}
|
||||
|
||||
Class* GetClass(const std::string& assemblyName,
|
||||
const std::string& nameSpaceName,
|
||||
const std::string& className) {
|
||||
if (!s_initialized) return nullptr;
|
||||
|
||||
auto asmIt = GetClassMap().find(assemblyName);
|
||||
if (asmIt == GetClassMap().end()) return nullptr;
|
||||
|
||||
auto& nsMap = asmIt->second;
|
||||
|
||||
// exact namespace lookup
|
||||
auto nsIt = nsMap.find(nameSpaceName);
|
||||
if (nsIt != nsMap.end()) {
|
||||
auto clsIt = nsIt->second.find(className);
|
||||
if (clsIt != nsIt->second.end())
|
||||
return &clsIt->second;
|
||||
}
|
||||
|
||||
// when namespace is empty and not found above, scan all namespaces
|
||||
if (nameSpaceName.empty()) {
|
||||
for (auto& [ns, clsMap] : nsMap) {
|
||||
auto clsIt = clsMap.find(className);
|
||||
if (clsIt != clsMap.end())
|
||||
return &clsIt->second;
|
||||
}
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
Method* GetMethod(const std::string& assemblyName,
|
||||
const std::string& nameSpaceName,
|
||||
const std::string& className,
|
||||
const std::string& methodName,
|
||||
const std::vector<std::string>& args) {
|
||||
auto* cls = GetClass(assemblyName, nameSpaceName, className);
|
||||
if (!cls)
|
||||
{
|
||||
GakumasLocal::Log::ErrorFmt("GetMethod failed: class not found. class: %s::%s, method: %s", nameSpaceName.c_str(), className.c_str(), methodName.c_str());
|
||||
return nullptr;
|
||||
}
|
||||
auto* ret = cls->GetMethod(methodName, args);
|
||||
if (!ret)
|
||||
{
|
||||
if (methodName == ".ctor")
|
||||
{
|
||||
ret = cls->GetMethod(className, args);
|
||||
if (ret) return ret;
|
||||
}
|
||||
|
||||
GakumasLocal::Log::ErrorFmt("GetMethod failed: method not found. class: %s::%s, method: %s", nameSpaceName.c_str(), className.c_str(), methodName.c_str());
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
} // namespace Il2cppJson
|
||||
|
|
@ -0,0 +1,123 @@
|
|||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include <cstdint>
|
||||
|
||||
#include "GakumasLocalify/GakumasLocalify/Local.h"
|
||||
#include "GakumasLocalify/GakumasLocalify/Log.h"
|
||||
|
||||
namespace Il2cppJson {
|
||||
// inline static uintptr_t s_baseAddress = 0;
|
||||
|
||||
inline uintptr_t& GetUnityBaseAddress()
|
||||
{
|
||||
static uintptr_t s_baseAddress = 0;
|
||||
return s_baseAddress;
|
||||
}
|
||||
|
||||
inline std::map<std::string, uintptr_t>& GetIl2cppAddressMap() {
|
||||
static std::map<std::string, uintptr_t> il2cppAddress {
|
||||
{ "il2cpp_object_new", 0x9D710C4 }, // 2.10.1、 2.10.2
|
||||
{ "il2cpp_class_get_method_from_name", 0x9DCC534 },
|
||||
{ "il2cpp_string_new", 0x9D7110C },
|
||||
{ "il2cpp_class_get_field_from_name", 0x9DCC2B0 },
|
||||
{ "il2cpp_class_from_type", 0x9D70E30},
|
||||
{ "il2cpp_class_get_fields", 0x9DCC1DC },
|
||||
{ "il2cpp_field_static_get_value_0+1", 0x9DC8D00 },
|
||||
{ "il2cpp_class_from_system_type", 0x9DCC028 },
|
||||
{ "il2cpp_init", 0x9D70D90 },
|
||||
{ "il2cpp_class_from_name", 0x9DCE4A4 },
|
||||
{ "il2cpp_assembly_get_image", 0x7C11B50 },
|
||||
{ "il2cpp_domain_get", 0x9DB81AC },
|
||||
{ "il2cpp_domain_assembly_open", 0x9D70EE4 },
|
||||
{ "il2cpp_domain_assembly_open+1", 0x9DA374C },
|
||||
{ "il2cpp_resolve_icall", 0x9D71304 },
|
||||
|
||||
// il2cpp_class_get_parent
|
||||
// il2cpp_resolve_icall
|
||||
// il2cpp_class_get_nested_types
|
||||
// il2cpp_type_get_object
|
||||
// il2cpp_class_get_type
|
||||
// il2cpp_field_static_set_value
|
||||
// il2cpp_runtime_invoke
|
||||
// il2cpp_thread_attach
|
||||
// il2cpp_domain_get_assemblies
|
||||
// il2cpp_image_get_filename
|
||||
// il2cpp_image_get_name
|
||||
// il2cpp_image_get_class_count
|
||||
// il2cpp_image_get_class
|
||||
// ...
|
||||
};
|
||||
return il2cppAddress;
|
||||
}
|
||||
|
||||
template <typename Return, typename... Args>
|
||||
auto InvokeAddress(uintptr_t address, Args... args) -> Return {
|
||||
return reinterpret_cast<Return(*)(Args...)>(address)(args...);
|
||||
}
|
||||
|
||||
template <typename Return, typename... Args>
|
||||
auto InvokeIl2cpp(const std::string& name, Args... args) -> Return {
|
||||
if (auto it = GetIl2cppAddressMap().find(name); it != GetIl2cppAddressMap().end())
|
||||
{
|
||||
// GakumasLocal::Log::InfoFmt("InvokeIl2cpp: %s", name.c_str());
|
||||
return InvokeAddress<Return>(GetUnityBaseAddress() + it->second, args...);
|
||||
}
|
||||
// GakumasLocal::Log::InfoFmt("InvokeIl2cpp failed: %s", name.c_str());
|
||||
|
||||
// return nullptr;
|
||||
if constexpr (!std::is_void_v<Return>)
|
||||
{
|
||||
return Return{};
|
||||
}
|
||||
}
|
||||
|
||||
struct Method {
|
||||
std::string name;
|
||||
std::vector<std::string> paramTypes;
|
||||
int paramCount = 0;
|
||||
uintptr_t address = 0;
|
||||
|
||||
template <typename Return, typename... Args>
|
||||
auto Invoke(Args... args) -> Return {
|
||||
return reinterpret_cast<Return(*)(Args...)>(address)(args...);
|
||||
}
|
||||
};
|
||||
|
||||
struct Class {
|
||||
std::string assemblyName;
|
||||
std::string namespaceName;
|
||||
std::string className;
|
||||
// methodName -> overloaded methods
|
||||
std::map<std::string, std::vector<Method>> methods;
|
||||
|
||||
Method* GetMethod(const std::string& methodName,
|
||||
const std::vector<std::string>& args = {});
|
||||
|
||||
// template <typename T>
|
||||
static void* New(void* address) {
|
||||
return InvokeIl2cpp<void*>("il2cpp_object_new", address);
|
||||
}
|
||||
};
|
||||
|
||||
// assembly -> namespace -> className -> Class
|
||||
using ClassMap = std::map<std::string, std::map<std::string, std::map<std::string, Class>>>;
|
||||
|
||||
/// Initialize the parser. Must be called before any GetClass/GetMethod calls.
|
||||
/// @param baseAddress Runtime base address of the UnityFramework image.
|
||||
/// {HOME}/Documents/gakumas-localify/il2cpp.json
|
||||
bool Init(uintptr_t baseAddress);
|
||||
|
||||
Class* GetClass(const std::string& assemblyName,
|
||||
const std::string& nameSpaceName,
|
||||
const std::string& className);
|
||||
|
||||
Method* GetMethod(const std::string& assemblyName,
|
||||
const std::string& nameSpaceName,
|
||||
const std::string& className,
|
||||
const std::string& methodName,
|
||||
const std::vector<std::string>& args = {});
|
||||
|
||||
} // namespace Il2cppJson
|
||||
|
|
@ -0,0 +1,164 @@
|
|||
#pragma once
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
#include "Il2cppJson.hpp"
|
||||
#include "../GakumasLocalify/Misc.hpp"
|
||||
#include "../GakumasLocalify/Log.h"
|
||||
|
||||
namespace Il2cppTypes
|
||||
{
|
||||
struct Il2CppObject
|
||||
{
|
||||
union
|
||||
{
|
||||
void* klass;
|
||||
void* vtable;
|
||||
};
|
||||
void* monitor;
|
||||
};
|
||||
|
||||
struct String {
|
||||
// int32_t m_stringLength{ 0 };
|
||||
// wchar_t m_firstChar[32]{};
|
||||
Il2CppObject object;
|
||||
int32_t length; ///< Length of string *excluding* the trailing null (which is included in
|
||||
///< 'chars').
|
||||
char16_t chars[1];
|
||||
|
||||
[[nodiscard]] auto ToString() const -> std::string {
|
||||
|
||||
if (!this) return {};
|
||||
try {
|
||||
// using convert_typeX = std::codecvt_utf8<wchar_t>;
|
||||
// std::wstring_convert<convert_typeX> converterX;
|
||||
// return converterX.to_bytes(m_firstChar);
|
||||
return GakumasLocal::Misc::ToUTF8(chars);
|
||||
}
|
||||
catch (std::exception& e) {
|
||||
std::cout << "String Invoke Error\n";
|
||||
GakumasLocal::Log::ErrorFmt("String Invoke Error: %s", e.what());
|
||||
return {};
|
||||
}
|
||||
}
|
||||
|
||||
[[nodiscard]] auto ToWString() const -> std::u16string {
|
||||
if (!this) return {};
|
||||
try {
|
||||
// using convert_typeX = std::codecvt_utf8<wchar_t>;
|
||||
// std::wstring_convert<convert_typeX> converterX;
|
||||
// return converterX.to_bytes(m_firstChar);
|
||||
return {chars};
|
||||
}
|
||||
catch (std::exception& e) {
|
||||
std::cout << "String Invoke Error\n";
|
||||
GakumasLocal::Log::ErrorFmt("String Invoke Error: %s", e.what());
|
||||
return {};
|
||||
}
|
||||
}
|
||||
|
||||
// auto operator=(const std::string& newString) const -> String* { return New(newString); }
|
||||
|
||||
auto operator==(const std::wstring& newString) const -> bool { return Equals(newString); }
|
||||
|
||||
auto Clear() -> void {
|
||||
if (!this) return;
|
||||
memset(chars, 0, length);
|
||||
length = 0;
|
||||
}
|
||||
|
||||
[[nodiscard]] auto Equals(const std::wstring& newString) const -> bool {
|
||||
if (!this) return false;
|
||||
if (newString.size() != length) return false;
|
||||
if (std::memcmp(newString.data(), chars, length) != 0) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
static auto New(const std::string& str) -> String* {
|
||||
return Il2cppJson::InvokeIl2cpp<String*, const char*>("il2cpp_string_new", str.c_str());
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct Array : Il2CppObject {
|
||||
struct {
|
||||
std::uintptr_t length;
|
||||
std::int32_t lower_bound;
|
||||
}*bounds{ nullptr };
|
||||
|
||||
std::uintptr_t max_length{ 0 };
|
||||
__declspec(align(8)) T** vector {};
|
||||
|
||||
auto GetData() -> uintptr_t { return reinterpret_cast<uintptr_t>(&vector); }
|
||||
|
||||
auto operator[](const unsigned int m_uIndex) -> T& { return *reinterpret_cast<T*>(GetData() + sizeof(T) * m_uIndex); }
|
||||
|
||||
auto At(const unsigned int m_uIndex) -> T& { return operator[](m_uIndex); }
|
||||
|
||||
auto Insert(T* m_pArray, uintptr_t m_uSize, const uintptr_t m_uIndex = 0) -> void {
|
||||
if ((m_uSize + m_uIndex) >= max_length) {
|
||||
if (m_uIndex >= max_length) return;
|
||||
|
||||
m_uSize = max_length - m_uIndex;
|
||||
}
|
||||
|
||||
for (uintptr_t u = 0; m_uSize > u; ++u) operator[](u + m_uIndex) = m_pArray[u];
|
||||
}
|
||||
|
||||
auto Fill(T m_tValue) -> void { for (uintptr_t u = 0; max_length > u; ++u) operator[](u) = m_tValue; }
|
||||
|
||||
auto RemoveAt(const unsigned int m_uIndex) -> void {
|
||||
if (m_uIndex >= max_length) return;
|
||||
|
||||
if (max_length > (m_uIndex + 1)) for (auto u = m_uIndex; (max_length - m_uIndex) > u; ++u) operator[](u) = operator[](u + 1);
|
||||
|
||||
--max_length;
|
||||
}
|
||||
|
||||
auto RemoveRange(const unsigned int m_uIndex, unsigned int m_uCount) -> void {
|
||||
if (m_uCount == 0) m_uCount = 1;
|
||||
|
||||
const auto m_uTotal = m_uIndex + m_uCount;
|
||||
if (m_uTotal >= max_length) return;
|
||||
|
||||
if (max_length > (m_uTotal + 1)) for (auto u = m_uIndex; (max_length - m_uTotal) >= u; ++u) operator[](u) = operator[](u + m_uCount);
|
||||
|
||||
max_length -= m_uCount;
|
||||
}
|
||||
/*
|
||||
auto RemoveAll() -> void {
|
||||
if (max_length > 0) {
|
||||
memset(GetData(), 0, sizeof(Type) * max_length);
|
||||
max_length = 0;
|
||||
}
|
||||
}*/
|
||||
|
||||
auto ToVector() -> std::vector<T> {
|
||||
#if WINDOWS_MODE
|
||||
if (IsBadReadPtr(this, sizeof(Array))) return {};
|
||||
#endif
|
||||
if (!this) return {};
|
||||
try {
|
||||
std::vector<T> rs{};
|
||||
rs.reserve(this->max_length);
|
||||
for (auto i = 0; i < this->max_length; i++) rs.push_back(this->At(i));
|
||||
return rs;
|
||||
} catch (...) {
|
||||
std::cout << "Array Invoke Error\n";
|
||||
return {};
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
auto Resize(int newSize) -> void {
|
||||
static Method* method;
|
||||
if (!method) method = Get("mscorlib.dll")->Get("Array")->Get<Method>("Resize");
|
||||
if (method) return method->Invoke<void>(this, newSize);
|
||||
}
|
||||
|
||||
static auto New(const Class* kalss, const std::uintptr_t size) -> Array* {
|
||||
if (mode_ == Mode::Il2Cpp) return UnityResolve::Invoke<Array*, void*, std::uintptr_t>("il2cpp_array_new", kalss->address, size);
|
||||
return UnityResolve::Invoke<Array*, void*, void*, std::uintptr_t>("mono_array_new", pDomain, kalss->address, size);
|
||||
}*/
|
||||
};
|
||||
}
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
TARGET := iphone:clang:latest:15.0
|
||||
ARCHS := arm64
|
||||
FINALPACKAGE = 1
|
||||
FOR_RELEASE = 1
|
||||
|
||||
THEOS = /home/chinosk/theos
|
||||
|
||||
include $(THEOS)/makefiles/common.mk
|
||||
|
||||
LIBRARY_NAME = GakumasLocalifyIOS
|
||||
|
||||
#ALL_MINIZIP_C = $(wildcard includes/SSZipArchive/minizip/*.c)
|
||||
#MINIZIP_FILES = $(filter-out %mz_crypt.c %mz_crypt_apple.c %mz_os_win32.c %mz_strm_win32.c, $(ALL_MINIZIP_C))
|
||||
|
||||
GakumasLocalifyIOS_FILES = \
|
||||
src/Entry.mm \
|
||||
src/UpdateChecker.mm \
|
||||
src/Plugin.cpp \
|
||||
src/IOSHookInstaller.mm \
|
||||
GakumasLocalify/GakumasLocalify/Plugin.cpp \
|
||||
GakumasLocalify/GakumasLocalify/Hook.cpp \
|
||||
GakumasLocalify/GakumasLocalify/Log.cpp \
|
||||
GakumasLocalify/GakumasLocalify/Misc.cpp \
|
||||
GakumasLocalify/GakumasLocalify/Local.cpp \
|
||||
GakumasLocalify/GakumasLocalify/MasterLocal.cpp \
|
||||
GakumasLocalify/GakumasLocalify/config/Config.cpp \
|
||||
GakumasLocalify/GakumasLocalify/string_parser/StringParser.cpp \
|
||||
GakumasLocalify/il2cpp_dump/Il2cppJson.cpp \
|
||||
$(wildcard includes/SSZipArchive/SSZipArchive.m) \
|
||||
$(wildcard includes/SSZipArchive/minizip/*.c)
|
||||
|
||||
ZIP_ARCHIVE_DEFINES = -DHAVE_INTTYPES_H -DHAVE_PKCRYPT -DHAVE_STDINT_H -DHAVE_WZAES -DHAVE_ZLIB
|
||||
|
||||
GakumasLocalifyIOS_CFLAGS += -fobjc-arc -Wno-error -Wno-unused-function $(ZIP_ARCHIVE_DEFINES)
|
||||
|
||||
COMMON_CCFLAGS = -DFMT_HEADER_ONLY -Wno-c++11-narrowing -Wno-unused-function -Wno-deprecated-declarations -fdeclspec -Wno-error \
|
||||
-IGakumasLocalify/deps \
|
||||
-IGakumasLocalify/deps/fmt-11.0.2/include \
|
||||
-IGakumasLocalify/il2cpp_dump
|
||||
|
||||
GakumasLocalifyIOS_CCFLAGS += -std=c++20 $(COMMON_CCFLAGS)
|
||||
|
||||
#src/UpdateChecker.mm_CCFLAGS = -std=c++11 $(COMMON_CCFLAGS)
|
||||
#src/Entry.mm_CCFLAGS = -std=c++11 $(COMMON_CCFLAGS)
|
||||
#src/IOSHookInstaller.mm_CCFLAGS = -std=c++11 $(COMMON_CCFLAGS)
|
||||
|
||||
GakumasLocalifyIOS_OBJCCFLAGS += -std=c++17 -Wno-error -Wno-unused-function
|
||||
|
||||
|
||||
GakumasLocalifyIOS_INCLUDE_PATHS += \
|
||||
GakumasLocalify \
|
||||
GakumasLocalify/deps \
|
||||
GakumasLocalify/deps/fmt-11.0.2/include \
|
||||
GakumasLocalify/il2cpp_dump
|
||||
|
||||
GakumasLocalifyIOS_FRAMEWORKS += Foundation UIKit
|
||||
GakumasLocalifyIOS_LDFLAGS += -ldl -lz -Wl,-undefined,dynamic_lookup
|
||||
|
||||
include $(THEOS_MAKE_PATH)/library.mk
|
||||
19
README.md
19
README.md
|
|
@ -1 +1,18 @@
|
|||
# gkms-localify-ios
|
||||
# gkms-localify-ios
|
||||
|
||||
- [Theos](https://theos.dev/) required
|
||||
|
||||
|
||||
|
||||
# Usage
|
||||
|
||||
- Use it with [LiveContainer](https://livecontainer.github.io/)
|
||||
- Enable [JIT](https://livecontainer.github.io/docs/guides/jit-support)
|
||||
|
||||
## For iOS 26+
|
||||
|
||||
- Use `StikDebug(Another LiveContainer)` or `StikDebug` to enable JIT.
|
||||
|
||||
- Use JIT script: `ScriptsAndBinary/Geode.js`
|
||||
- Load `ScriptsAndBinary/libdobby.dylib`
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,158 @@
|
|||
function littleEndianHexStringToNumber(hexStr) {
|
||||
const bytes = [];
|
||||
for (let i = 0; i < hexStr.length; i += 2) {
|
||||
bytes.push(parseInt(hexStr.substr(i, 2), 16));
|
||||
}
|
||||
let num = 0n;
|
||||
for (let i = 4; i >= 0; i--) {
|
||||
num = (num << 8n) | BigInt(bytes[i]);
|
||||
}
|
||||
return num;
|
||||
}
|
||||
|
||||
function numberToLittleEndianHexString(num) {
|
||||
const bytes = [];
|
||||
for (let i = 0; i < 5; i++) {
|
||||
bytes.push(Number(num & 0xFFn));
|
||||
num >>= 8n;
|
||||
}
|
||||
while (bytes.length < 8) {
|
||||
bytes.push(0);
|
||||
}
|
||||
return bytes.map(b => b.toString(16).padStart(2, '0')).join('');
|
||||
}
|
||||
|
||||
function littleEndianHexToU32(hexStr) {
|
||||
return parseInt(hexStr.match(/../g).reverse().join(''), 16);
|
||||
}
|
||||
|
||||
function extractBrkImmediate(u32) {
|
||||
return (u32 >> 5) & 0xFFFF;
|
||||
}
|
||||
|
||||
let pid = get_pid();
|
||||
log(`[GakumasBk] pid = ${pid}`);
|
||||
let attachResponse = send_command(`vAttach;${pid.toString(16)}`);
|
||||
log(`[GakumasBk] attach_response = ${attachResponse}`);
|
||||
|
||||
let validBreakpoints = 0;
|
||||
let totalBreakpoints = 0;
|
||||
let invalidBreakpoints = 0;
|
||||
|
||||
while (invalidBreakpoints < 10) {
|
||||
totalBreakpoints++;
|
||||
log(`[GakumasBk] Handling breakpoint ${totalBreakpoints} (valid: ${validBreakpoints})`);
|
||||
|
||||
let brkResponse = send_command(`c`);
|
||||
log(`[GakumasBk] brkResponse = ${brkResponse}`);
|
||||
|
||||
let tidMatch = /T[0-9a-f]+thread:(?<tid>[0-9a-f]+);/.exec(brkResponse);
|
||||
let tid = tidMatch ? tidMatch.groups['tid'] : null;
|
||||
let pcMatch = /20:(?<reg>[0-9a-f]{16});/.exec(brkResponse);
|
||||
let pc = pcMatch ? pcMatch.groups['reg'] : null;
|
||||
let x0Match = /00:(?<reg>[0-9a-f]{16});/.exec(brkResponse);
|
||||
let x0 = x0Match ? x0Match.groups['reg'] : null;
|
||||
let x1Match = /01:(?<reg>[0-9a-f]{16});/.exec(brkResponse);
|
||||
let x1 = x1Match ? x1Match.groups['reg'] : null;
|
||||
|
||||
if (!tid || !pc || !x0) {
|
||||
log(`[GakumasBk] Failed to extract registers: tid=${tid}, pc=${pc}, x0=${x0}, x1=${x1}`);
|
||||
invalidBreakpoints++;
|
||||
continue;
|
||||
}
|
||||
|
||||
const pcNum = littleEndianHexStringToNumber(pc);
|
||||
const x0Num = littleEndianHexStringToNumber(x0);
|
||||
const x1Num = x1 ? littleEndianHexStringToNumber(x1) : 0n;
|
||||
log(`[GakumasBk] tid = ${tid}, pc = ${pcNum.toString(16)}, x0 = ${x0Num.toString(16)}, x1 = ${x1Num.toString(16)}`);
|
||||
|
||||
let instructionResponse = send_command(`m${pcNum.toString(16)},4`);
|
||||
log(`[GakumasBk] instruction at pc: ${instructionResponse}`);
|
||||
let instrU32 = littleEndianHexToU32(instructionResponse);
|
||||
let brkImmediate = extractBrkImmediate(instrU32);
|
||||
log(`[GakumasBk] BRK immediate: 0x${brkImmediate.toString(16)} (${brkImmediate})`);
|
||||
|
||||
if (brkImmediate !== 0x69 && brkImmediate !== 0x70 && brkImmediate !== 0x71) {
|
||||
log(`[GakumasBk] Skipping: BRK immediate not 0x69 or 0x70 or 0x71 (was 0x${brkImmediate.toString(16)})`);
|
||||
invalidBreakpoints++;
|
||||
continue;
|
||||
}
|
||||
invalidBreakpoints = 0;
|
||||
|
||||
if (brkImmediate === 0x69) { // usual jit mapping
|
||||
log(`[GakumasBk] Received command to process JIT mapping (0x69)`);
|
||||
|
||||
let jitPageAddress = x0Num;
|
||||
let size = x1Num > 0n ? x1Num : 0x10000n; // allocate 64 KB if x1 somehow is 0
|
||||
log(`[GakumasBk] Got RX page address: 0x${jitPageAddress.toString(16)}, preparing region with 0x${size.toString(16)} bytes!`);
|
||||
|
||||
let prepareJITPageResponse = prepare_memory_region(Number(jitPageAddress), Number(size)); // Unsure if this is specific to iOS26 but this func doesnt take in a BigInt, resulting in an error unless converted to a number. I'm not sure how other scripts don't have this problem.
|
||||
log(`[GakumasBk] prepareJITPageResponse = ${prepareJITPageResponse}`);
|
||||
|
||||
let pcPlus4 = numberToLittleEndianHexString(pcNum + 4n);
|
||||
let pcPlus4Response = send_command(`P20=${pcPlus4};thread:${tid};`);
|
||||
log(`[GakumasBk] pcPlus4Response = ${pcPlus4Response}`);
|
||||
validBreakpoints++;
|
||||
} else if (brkImmediate === 0x70) { // patching instructs
|
||||
log(`[GakumasBk] Received command to patch instructions (0x70)`);
|
||||
|
||||
let x2Match = /02:(?<reg>[0-9a-f]{16});/.exec(brkResponse);
|
||||
let x2 = x2Match ? x2Match.groups['reg'] : null;
|
||||
|
||||
if (!x1 || !x2) {
|
||||
log(`[GakumasBk] Missing x1 or x2 for function patching`);
|
||||
continue;
|
||||
}
|
||||
|
||||
let destAddr = x0Num;
|
||||
let srcAddr = x1Num;
|
||||
let size = x2 ? littleEndianHexStringToNumber(x2) : 10n;
|
||||
log(`[GakumasBk] Patching: dest=0x${destAddr.toString(16)}, src=0x${srcAddr.toString(16)}, size=0x${size.toString(16)}`);
|
||||
|
||||
// Unsure exactly why, but anything over 4 MB freezes the app for some reason, so we will set a soft limit
|
||||
if (size > 0x400000n) {
|
||||
log(`[GakumasBk] Size too large (0x${size.toString(16)}), skipping`);
|
||||
let pcPlus4 = numberToLittleEndianHexString(pcNum + 4n);
|
||||
let pcPlus4Response = send_command(`P20=${pcPlus4};thread:${tid};`);
|
||||
log(`[GakumasBk] pcPlus4Response = ${pcPlus4Response}`);
|
||||
validBreakpoints++;
|
||||
continue;
|
||||
}
|
||||
try {
|
||||
// m (read) = `m${curPointer.toString(16)},<size>`
|
||||
// M (write) = `M${curPointer.toString(16)},<size>:<your hex instructions goes here>`
|
||||
const CHUNK_SIZE = 0x4000n; // 16 KB
|
||||
for (let i = 0n; i < size; i += CHUNK_SIZE) {
|
||||
let chunkSize = i + CHUNK_SIZE <= size ? CHUNK_SIZE : size - i;
|
||||
let readAddr = srcAddr + i;
|
||||
let writeAddr = destAddr + i;
|
||||
let readRes = send_command(`m${readAddr.toString(16)},${chunkSize.toString(16)}`);
|
||||
if (readRes && readRes.length > 0) {
|
||||
let writeResponse = send_command(`M${writeAddr.toString(16)},${chunkSize.toString(16)}:${readRes}`);
|
||||
if (writeResponse !== "OK") {
|
||||
log(`[GakumasBk] Write failed at offset ${i.toString(16)}`);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (Number(i / CHUNK_SIZE) % 10 === 0) {
|
||||
log(`[GakumasBk] Progress: 0x${i.toString(16)}/0x${size.toString(16)}`);
|
||||
}
|
||||
}
|
||||
log(`[GakumasBk] Memory write completed!`);
|
||||
} catch (e) {
|
||||
log(`[GakumasBk] Memory write failed: ${e}`);
|
||||
}
|
||||
|
||||
let pcPlus4 = numberToLittleEndianHexString(pcNum + 4n);
|
||||
let pcPlus4Response = send_command(`P20=${pcPlus4};thread:${tid};`);
|
||||
log(`[GakumasBk] pcPlus4Response = ${pcPlus4Response}`);
|
||||
validBreakpoints++;
|
||||
} else if (brkImmediate === 0x71) { // detach, might be unnecessary
|
||||
break;
|
||||
}
|
||||
|
||||
log(`[GakumasBk] Completed breakpoint ${validBreakpoints}`);
|
||||
}
|
||||
log(`[GakumasBk] Stopping script (Received 0x71 or too many invalid breakpoints)`);
|
||||
let detachResponse = send_command(`D`);
|
||||
log(`[GakumasBk] detachResponse = ${detachResponse}`);
|
||||
Binary file not shown.
|
|
@ -0,0 +1,8 @@
|
|||
Package: io.github.chinosk.gkms-localify
|
||||
Name: Gakumas Localify
|
||||
Version: 3.2.0 Beta 1
|
||||
Architecture: iphoneos-arm
|
||||
Description: Gakumas localization plugin
|
||||
Maintainer: chinosk
|
||||
Author: chinosk
|
||||
Depends: mobilesubstrate (>= 0.9.5000)
|
||||
|
|
@ -0,0 +1,262 @@
|
|||
#!/usr/bin/env python3
|
||||
"""
|
||||
Convert il2cpp.json to a flat binary format (.bin) for fast loading.
|
||||
|
||||
Pre-processes all string parsing (parseGroup, parseDotNetSignature) so the
|
||||
C++ Init function can load pre-computed data directly, avoiding JSON parsing
|
||||
and regex-like string operations at app startup.
|
||||
|
||||
Binary format (all integers little-endian):
|
||||
|
||||
Header (16 bytes):
|
||||
char[4] magic = "ILCB"
|
||||
uint32 version = 1
|
||||
uint32 method_count
|
||||
uint32 total_param_count
|
||||
|
||||
MethodEntry[method_count] (each 48 bytes):
|
||||
uint32 assembly_off, assembly_len (into string pool)
|
||||
uint32 namespace_off, namespace_len
|
||||
uint32 classname_off, classname_len
|
||||
uint32 methodname_off, methodname_len
|
||||
uint32 param_count
|
||||
uint32 params_start_idx (index into ParamRef array)
|
||||
uint64 rva
|
||||
|
||||
ParamRef[total_param_count] (each 8 bytes):
|
||||
uint32 str_off, str_len (into string pool)
|
||||
|
||||
StringPool:
|
||||
raw UTF-8 bytes (no null terminators; lengths are explicit)
|
||||
|
||||
Usage:
|
||||
python convert_il2cpp_json_to_bin.py <il2cpp.json> [output.bin]
|
||||
"""
|
||||
|
||||
import json
|
||||
import struct
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
def parse_group(group: str):
|
||||
"""
|
||||
Parse `group` field into (assembly, namespace, class_name).
|
||||
"Assembly-CSharp.dll/Campus/OutGame/SomePresenter"
|
||||
-> ("Assembly-CSharp.dll", "Campus.OutGame", "SomePresenter")
|
||||
"""
|
||||
dll_pos = group.find(".dll")
|
||||
if dll_pos == -1:
|
||||
return None
|
||||
assembly = group[:dll_pos + 4]
|
||||
|
||||
rest_start = dll_pos + 4
|
||||
if rest_start < len(group) and group[rest_start] == '/':
|
||||
rest_start += 1
|
||||
if rest_start >= len(group):
|
||||
return None
|
||||
|
||||
rest = group[rest_start:]
|
||||
parts = rest.split('/')
|
||||
if not parts:
|
||||
return None
|
||||
|
||||
class_name = parts[-1]
|
||||
namespace = '.'.join(parts[:-1])
|
||||
return assembly, namespace, class_name
|
||||
|
||||
|
||||
def split_params(param_str: str):
|
||||
"""Bracket-aware split of a parameter list string by comma."""
|
||||
if not param_str.strip():
|
||||
return []
|
||||
|
||||
result = []
|
||||
depth = 0
|
||||
current = []
|
||||
|
||||
for c in param_str:
|
||||
if c in ('[', '<', '('):
|
||||
depth += 1
|
||||
current.append(c)
|
||||
elif c in (']', '>', ')'):
|
||||
depth -= 1
|
||||
current.append(c)
|
||||
elif c == ',' and depth == 0:
|
||||
t = ''.join(current).strip()
|
||||
if t:
|
||||
result.append(t)
|
||||
current = []
|
||||
else:
|
||||
current.append(c)
|
||||
|
||||
t = ''.join(current).strip()
|
||||
if t:
|
||||
result.append(t)
|
||||
return result
|
||||
|
||||
|
||||
def parse_dot_net_signature(sig: str):
|
||||
"""
|
||||
Parse dotNetSignature into (method_name, [param_types]).
|
||||
"Void SetItemModels(IReadOnlyList`1[X])"
|
||||
-> ("SetItemModels", ["IReadOnlyList`1[X]"])
|
||||
"""
|
||||
paren_open = sig.find('(')
|
||||
if paren_open == -1:
|
||||
return None
|
||||
|
||||
prefix = sig[:paren_open]
|
||||
last_space = prefix.rfind(' ')
|
||||
method_name = prefix[last_space + 1:] if last_space != -1 else prefix
|
||||
|
||||
if not method_name:
|
||||
return None
|
||||
|
||||
paren_close = sig.rfind(')')
|
||||
if paren_close == -1 or paren_close <= paren_open:
|
||||
return method_name, []
|
||||
|
||||
param_str = sig[paren_open + 1:paren_close].strip()
|
||||
param_types = split_params(param_str)
|
||||
return method_name, param_types
|
||||
|
||||
|
||||
def parse_hex_address(hex_str: str) -> int:
|
||||
try:
|
||||
return int(hex_str, 16)
|
||||
except (ValueError, TypeError):
|
||||
return 0
|
||||
|
||||
|
||||
class StringPool:
|
||||
"""Deduplicating UTF-8 string pool."""
|
||||
|
||||
def __init__(self):
|
||||
self._pool = bytearray()
|
||||
self._cache: dict[str, tuple[int, int]] = {}
|
||||
|
||||
def add(self, s: str) -> tuple[int, int]:
|
||||
if s in self._cache:
|
||||
return self._cache[s]
|
||||
encoded = s.encode('utf-8')
|
||||
offset = len(self._pool)
|
||||
length = len(encoded)
|
||||
self._pool.extend(encoded)
|
||||
self._cache[s] = (offset, length)
|
||||
return offset, length
|
||||
|
||||
def data(self) -> bytes:
|
||||
return bytes(self._pool)
|
||||
|
||||
|
||||
HEADER_FMT = '<4sIII' # magic(4) + version + method_count + total_param_count
|
||||
METHOD_FMT = '<IIIIIIIIIIQ' # 10×uint32 + 1×uint64 = 48 bytes
|
||||
PARAM_FMT = '<II' # 2×uint32 = 8 bytes
|
||||
|
||||
HEADER_SIZE = struct.calcsize(HEADER_FMT) # 16
|
||||
METHOD_SIZE = struct.calcsize(METHOD_FMT) # 48
|
||||
PARAM_SIZE = struct.calcsize(PARAM_FMT) # 8
|
||||
|
||||
|
||||
def convert(input_path: str, output_path: str):
|
||||
with open(input_path, 'r', encoding='utf-8') as f:
|
||||
root = json.load(f)
|
||||
|
||||
defs = root.get("addressMap", {}).get("methodDefinitions", [])
|
||||
|
||||
pool = StringPool()
|
||||
methods = []
|
||||
total_params = 0
|
||||
error_count = 0
|
||||
|
||||
for entry in defs:
|
||||
group = entry.get("group")
|
||||
dot_net_sig = entry.get("dotNetSignature")
|
||||
va_str = entry.get("virtualAddress")
|
||||
|
||||
if not group or not dot_net_sig or not va_str:
|
||||
error_count += 1
|
||||
continue
|
||||
|
||||
parsed_group = parse_group(group)
|
||||
if not parsed_group:
|
||||
error_count += 1
|
||||
continue
|
||||
assembly, namespace, class_name = parsed_group
|
||||
|
||||
parsed_sig = parse_dot_net_signature(dot_net_sig)
|
||||
if not parsed_sig:
|
||||
error_count += 1
|
||||
continue
|
||||
method_name, param_types = parsed_sig
|
||||
|
||||
rva = parse_hex_address(va_str)
|
||||
|
||||
asm_off, asm_len = pool.add(assembly)
|
||||
ns_off, ns_len = pool.add(namespace)
|
||||
cls_off, cls_len = pool.add(class_name)
|
||||
meth_off, meth_len = pool.add(method_name)
|
||||
|
||||
param_refs = []
|
||||
for pt in param_types:
|
||||
pt_off, pt_len = pool.add(pt)
|
||||
param_refs.append((pt_off, pt_len))
|
||||
|
||||
methods.append({
|
||||
'assembly': (asm_off, asm_len),
|
||||
'namespace': (ns_off, ns_len),
|
||||
'classname': (cls_off, cls_len),
|
||||
'methodname': (meth_off, meth_len),
|
||||
'param_count': len(param_types),
|
||||
'params_start_idx': total_params,
|
||||
'param_refs': param_refs,
|
||||
'rva': rva,
|
||||
})
|
||||
total_params += len(param_types)
|
||||
|
||||
# --- build binary ---
|
||||
header = struct.pack(HEADER_FMT, b'ILCB', 1, len(methods), total_params)
|
||||
|
||||
method_buf = bytearray()
|
||||
for m in methods:
|
||||
method_buf.extend(struct.pack(
|
||||
METHOD_FMT,
|
||||
m['assembly'][0], m['assembly'][1],
|
||||
m['namespace'][0], m['namespace'][1],
|
||||
m['classname'][0], m['classname'][1],
|
||||
m['methodname'][0], m['methodname'][1],
|
||||
m['param_count'],
|
||||
m['params_start_idx'],
|
||||
m['rva'],
|
||||
))
|
||||
|
||||
param_buf = bytearray()
|
||||
for m in methods:
|
||||
for pr in m['param_refs']:
|
||||
param_buf.extend(struct.pack(PARAM_FMT, pr[0], pr[1]))
|
||||
|
||||
string_data = pool.data()
|
||||
|
||||
with open(output_path, 'wb') as f:
|
||||
f.write(header)
|
||||
f.write(method_buf)
|
||||
f.write(param_buf)
|
||||
f.write(string_data)
|
||||
|
||||
total_size = HEADER_SIZE + len(method_buf) + len(param_buf) + len(string_data)
|
||||
print(f"Done: {len(methods)} methods ({error_count} skipped) -> {output_path}")
|
||||
print(f" String pool : {len(string_data):,} bytes")
|
||||
print(f" Total params: {total_params:,}")
|
||||
print(f" File size : {total_size:,} bytes")
|
||||
|
||||
|
||||
def main():
|
||||
input_file = input("Enter the path to the il2cpp.json file: ")
|
||||
output_file = str(Path(input_file).with_suffix('.bin'))
|
||||
|
||||
convert(input_file, output_file)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
Copyright (c) 2013-2021, ZipArchive, https://github.com/ZipArchive
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of this software and associated documentation files (the
|
||||
"Software"), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sublicense, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so, subject to
|
||||
the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be
|
||||
included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
|
@ -0,0 +1,165 @@
|
|||
//
|
||||
// SSZipArchive.h
|
||||
// SSZipArchive
|
||||
//
|
||||
// Created by Sam Soffes on 7/21/10.
|
||||
//
|
||||
|
||||
#ifndef _SSZIPARCHIVE_H
|
||||
#define _SSZIPARCHIVE_H
|
||||
|
||||
#import <Foundation/Foundation.h>
|
||||
|
||||
#import "SSZipCommon.h"
|
||||
|
||||
NS_ASSUME_NONNULL_BEGIN
|
||||
|
||||
extern NSString *const SSZipArchiveErrorDomain;
|
||||
typedef NS_ENUM(NSInteger, SSZipArchiveErrorCode) {
|
||||
SSZipArchiveErrorCodeFailedOpenZipFile = -1,
|
||||
SSZipArchiveErrorCodeFailedOpenFileInZip = -2,
|
||||
SSZipArchiveErrorCodeFileInfoNotLoadable = -3,
|
||||
SSZipArchiveErrorCodeFileContentNotReadable = -4,
|
||||
SSZipArchiveErrorCodeFailedToWriteFile = -5,
|
||||
SSZipArchiveErrorCodeInvalidArguments = -6,
|
||||
};
|
||||
|
||||
@protocol SSZipArchiveDelegate;
|
||||
|
||||
@interface SSZipArchive : NSObject
|
||||
|
||||
// Password check
|
||||
+ (BOOL)isFilePasswordProtectedAtPath:(NSString *)path;
|
||||
+ (BOOL)isPasswordValidForArchiveAtPath:(NSString *)path password:(NSString *)pw error:(NSError * _Nullable * _Nullable)error NS_SWIFT_NOTHROW;
|
||||
|
||||
// Total payload size
|
||||
+ (NSNumber *)payloadSizeForArchiveAtPath:(NSString *)path error:(NSError **)error;
|
||||
|
||||
// Unzip
|
||||
+ (BOOL)unzipFileAtPath:(NSString *)path toDestination:(NSString *)destination;
|
||||
+ (BOOL)unzipFileAtPath:(NSString *)path toDestination:(NSString *)destination delegate:(nullable id<SSZipArchiveDelegate>)delegate;
|
||||
|
||||
+ (BOOL)unzipFileAtPath:(NSString *)path
|
||||
toDestination:(NSString *)destination
|
||||
overwrite:(BOOL)overwrite
|
||||
password:(nullable NSString *)password
|
||||
error:(NSError * *)error;
|
||||
|
||||
+ (BOOL)unzipFileAtPath:(NSString *)path
|
||||
toDestination:(NSString *)destination
|
||||
overwrite:(BOOL)overwrite
|
||||
password:(nullable NSString *)password
|
||||
error:(NSError * *)error
|
||||
delegate:(nullable id<SSZipArchiveDelegate>)delegate NS_REFINED_FOR_SWIFT;
|
||||
|
||||
+ (BOOL)unzipFileAtPath:(NSString *)path
|
||||
toDestination:(NSString *)destination
|
||||
preserveAttributes:(BOOL)preserveAttributes
|
||||
overwrite:(BOOL)overwrite
|
||||
password:(nullable NSString *)password
|
||||
error:(NSError * *)error
|
||||
delegate:(nullable id<SSZipArchiveDelegate>)delegate;
|
||||
|
||||
+ (BOOL)unzipFileAtPath:(NSString *)path
|
||||
toDestination:(NSString *)destination
|
||||
progressHandler:(void (^_Nullable)(NSString *entry, unz_file_info zipInfo, long entryNumber, long total))progressHandler
|
||||
completionHandler:(void (^_Nullable)(NSString *path, BOOL succeeded, NSError * _Nullable error))completionHandler;
|
||||
|
||||
+ (BOOL)unzipFileAtPath:(NSString *)path
|
||||
toDestination:(NSString *)destination
|
||||
overwrite:(BOOL)overwrite
|
||||
password:(nullable NSString *)password
|
||||
progressHandler:(void (^_Nullable)(NSString *entry, unz_file_info zipInfo, long entryNumber, long total))progressHandler
|
||||
completionHandler:(void (^_Nullable)(NSString *path, BOOL succeeded, NSError * _Nullable error))completionHandler;
|
||||
|
||||
+ (BOOL)unzipFileAtPath:(NSString *)path
|
||||
toDestination:(NSString *)destination
|
||||
preserveAttributes:(BOOL)preserveAttributes
|
||||
overwrite:(BOOL)overwrite
|
||||
nestedZipLevel:(NSInteger)nestedZipLevel
|
||||
password:(nullable NSString *)password
|
||||
error:(NSError **)error
|
||||
delegate:(nullable id<SSZipArchiveDelegate>)delegate
|
||||
progressHandler:(void (^_Nullable)(NSString *entry, unz_file_info zipInfo, long entryNumber, long total))progressHandler
|
||||
completionHandler:(void (^_Nullable)(NSString *path, BOOL succeeded, NSError * _Nullable error))completionHandler;
|
||||
|
||||
// Zip
|
||||
// default compression level is Z_DEFAULT_COMPRESSION (from "zlib.h")
|
||||
// keepParentDirectory: if YES, then unzipping will give `directoryName/fileName`. If NO, then unzipping will just give `fileName`. Default is NO.
|
||||
|
||||
// without password
|
||||
+ (BOOL)createZipFileAtPath:(NSString *)path withFilesAtPaths:(NSArray<NSString *> *)paths;
|
||||
+ (BOOL)createZipFileAtPath:(NSString *)path withContentsOfDirectory:(NSString *)directoryPath;
|
||||
|
||||
+ (BOOL)createZipFileAtPath:(NSString *)path withContentsOfDirectory:(NSString *)directoryPath keepParentDirectory:(BOOL)keepParentDirectory;
|
||||
|
||||
// with optional password, default encryption is AES
|
||||
// don't use AES if you need compatibility with native macOS unzip and Archive Utility
|
||||
+ (BOOL)createZipFileAtPath:(NSString *)path withFilesAtPaths:(NSArray<NSString *> *)paths withPassword:(nullable NSString *)password;
|
||||
+ (BOOL)createZipFileAtPath:(NSString *)path withFilesAtPaths:(NSArray<NSString *> *)paths withPassword:(nullable NSString *)password progressHandler:(void(^ _Nullable)(NSUInteger entryNumber, NSUInteger total))progressHandler;
|
||||
+ (BOOL)createZipFileAtPath:(NSString *)path withContentsOfDirectory:(NSString *)directoryPath withPassword:(nullable NSString *)password;
|
||||
+ (BOOL)createZipFileAtPath:(NSString *)path withContentsOfDirectory:(NSString *)directoryPath keepParentDirectory:(BOOL)keepParentDirectory withPassword:(nullable NSString *)password;
|
||||
+ (BOOL)createZipFileAtPath:(NSString *)path
|
||||
withContentsOfDirectory:(NSString *)directoryPath
|
||||
keepParentDirectory:(BOOL)keepParentDirectory
|
||||
withPassword:(nullable NSString *)password
|
||||
andProgressHandler:(void(^ _Nullable)(NSUInteger entryNumber, NSUInteger total))progressHandler;
|
||||
+ (BOOL)createZipFileAtPath:(NSString *)path
|
||||
withContentsOfDirectory:(NSString *)directoryPath
|
||||
keepParentDirectory:(BOOL)keepParentDirectory
|
||||
compressionLevel:(int)compressionLevel
|
||||
password:(nullable NSString *)password
|
||||
AES:(BOOL)aes
|
||||
progressHandler:(void(^ _Nullable)(NSUInteger entryNumber, NSUInteger total))progressHandler;
|
||||
//suport symlink compress --file
|
||||
+ (BOOL)createZipFileAtPath:(NSString *)path withFilesAtPaths:(NSArray<NSString *> *)paths withPassword:(nullable NSString *)password keepSymlinks:(BOOL)keeplinks;
|
||||
//suport symlink compress --directory
|
||||
+ (BOOL)createZipFileAtPath:(NSString *)path
|
||||
withContentsOfDirectory:(NSString *)directoryPath
|
||||
keepParentDirectory:(BOOL)keepParentDirectory
|
||||
compressionLevel:(int)compressionLevel
|
||||
password:(nullable NSString *)password
|
||||
AES:(BOOL)aes
|
||||
progressHandler:(void(^ _Nullable)(NSUInteger entryNumber, NSUInteger total))progressHandler
|
||||
keepSymlinks:(BOOL)keeplinks;
|
||||
|
||||
- (instancetype)init NS_UNAVAILABLE;
|
||||
- (instancetype)initWithPath:(NSString *)path NS_DESIGNATED_INITIALIZER;
|
||||
- (BOOL)open;
|
||||
- (BOOL)openForAppending;
|
||||
|
||||
/// write empty folder
|
||||
- (BOOL)writeFolderAtPath:(NSString *)path withFolderName:(NSString *)folderName withPassword:(nullable NSString *)password;
|
||||
/// write file
|
||||
- (BOOL)writeFile:(NSString *)path withPassword:(nullable NSString *)password;
|
||||
- (BOOL)writeFileAtPath:(NSString *)path withFileName:(nullable NSString *)fileName withPassword:(nullable NSString *)password;
|
||||
- (BOOL)writeFileAtPath:(NSString *)path withFileName:(nullable NSString *)fileName compressionLevel:(int)compressionLevel password:(nullable NSString *)password AES:(BOOL)aes;
|
||||
///write symlink files
|
||||
- (BOOL)writeSymlinkFileAtPath:(NSString *)path withFileName:(nullable NSString *)fileName compressionLevel:(int)compressionLevel password:(nullable NSString *)password AES:(BOOL)aes;
|
||||
/// write data
|
||||
- (BOOL)writeData:(NSData *)data filename:(nullable NSString *)filename withPassword:(nullable NSString *)password;
|
||||
- (BOOL)writeData:(NSData *)data filename:(nullable NSString *)filename compressionLevel:(int)compressionLevel password:(nullable NSString *)password AES:(BOOL)aes;
|
||||
|
||||
- (BOOL)close;
|
||||
|
||||
@end
|
||||
|
||||
@protocol SSZipArchiveDelegate <NSObject>
|
||||
|
||||
@optional
|
||||
|
||||
- (void)zipArchiveWillUnzipArchiveAtPath:(NSString *)path zipInfo:(unz_global_info)zipInfo;
|
||||
- (void)zipArchiveDidUnzipArchiveAtPath:(NSString *)path zipInfo:(unz_global_info)zipInfo unzippedPath:(NSString *)unzippedPath;
|
||||
|
||||
- (BOOL)zipArchiveShouldUnzipFileAtIndex:(NSInteger)fileIndex totalFiles:(NSInteger)totalFiles archivePath:(NSString *)archivePath fileInfo:(unz_file_info)fileInfo;
|
||||
- (void)zipArchiveWillUnzipFileAtIndex:(NSInteger)fileIndex totalFiles:(NSInteger)totalFiles archivePath:(NSString *)archivePath fileInfo:(unz_file_info)fileInfo;
|
||||
- (void)zipArchiveDidUnzipFileAtIndex:(NSInteger)fileIndex totalFiles:(NSInteger)totalFiles archivePath:(NSString *)archivePath fileInfo:(unz_file_info)fileInfo;
|
||||
- (void)zipArchiveDidUnzipFileAtIndex:(NSInteger)fileIndex totalFiles:(NSInteger)totalFiles archivePath:(NSString *)archivePath unzippedFilePath:(NSString *)unzippedFilePath;
|
||||
|
||||
- (void)zipArchiveProgressEvent:(unsigned long long)loaded total:(unsigned long long)total;
|
||||
|
||||
@end
|
||||
|
||||
NS_ASSUME_NONNULL_END
|
||||
|
||||
#endif /* _SSZIPARCHIVE_H */
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,68 @@
|
|||
#ifndef SSZipCommon
|
||||
#define SSZipCommon
|
||||
|
||||
// typedefs moved from mz_compat.h to here for public access
|
||||
|
||||
/* unz_global_info structure contain global data about the ZIPfile
|
||||
These data comes from the end of central dir */
|
||||
typedef struct unz_global_info64_s
|
||||
{
|
||||
uint64_t number_entry; /* total number of entries in the central dir on this disk */
|
||||
uint32_t number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP */
|
||||
uint16_t size_comment; /* size of the global comment of the zipfile */
|
||||
} unz_global_info64;
|
||||
|
||||
typedef struct unz_global_info_s
|
||||
{
|
||||
uint32_t number_entry; /* total number of entries in the central dir on this disk */
|
||||
uint32_t number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP */
|
||||
uint16_t size_comment; /* size of the global comment of the zipfile */
|
||||
} unz_global_info;
|
||||
|
||||
/* unz_file_info contain information about a file in the zipfile */
|
||||
/* https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT */
|
||||
typedef struct unz_file_info64_s
|
||||
{
|
||||
uint16_t version; /* version made by 2 bytes */
|
||||
uint16_t version_needed; /* version needed to extract 2 bytes */
|
||||
uint16_t flag; /* general purpose bit flag 2 bytes */
|
||||
uint16_t compression_method; /* compression method 2 bytes */
|
||||
uint32_t dos_date; /* last mod file date in Dos fmt 4 bytes */
|
||||
uint32_t crc; /* crc-32 4 bytes */
|
||||
uint64_t compressed_size; /* compressed size 8 bytes */
|
||||
uint64_t uncompressed_size; /* uncompressed size 8 bytes */
|
||||
uint16_t size_filename; /* filename length 2 bytes */
|
||||
uint16_t size_file_extra; /* extra field length 2 bytes */
|
||||
uint16_t size_file_comment; /* file comment length 2 bytes */
|
||||
|
||||
uint32_t disk_num_start; /* disk number start 4 bytes */
|
||||
uint16_t internal_fa; /* internal file attributes 2 bytes */
|
||||
uint32_t external_fa; /* external file attributes 4 bytes */
|
||||
|
||||
uint64_t disk_offset;
|
||||
|
||||
uint16_t size_file_extra_internal;
|
||||
} unz_file_info64;
|
||||
|
||||
typedef struct unz_file_info_s
|
||||
{
|
||||
uint16_t version; /* version made by 2 bytes */
|
||||
uint16_t version_needed; /* version needed to extract 2 bytes */
|
||||
uint16_t flag; /* general purpose bit flag 2 bytes */
|
||||
uint16_t compression_method; /* compression method 2 bytes */
|
||||
uint32_t dos_date; /* last mod file date in Dos fmt 4 bytes */
|
||||
uint32_t crc; /* crc-32 4 bytes */
|
||||
uint32_t compressed_size; /* compressed size 4 bytes */
|
||||
uint32_t uncompressed_size; /* uncompressed size 4 bytes */
|
||||
uint16_t size_filename; /* filename length 2 bytes */
|
||||
uint16_t size_file_extra; /* extra field length 2 bytes */
|
||||
uint16_t size_file_comment; /* file comment length 2 bytes */
|
||||
|
||||
uint16_t disk_num_start; /* disk number start 2 bytes */
|
||||
uint16_t internal_fa; /* internal file attributes 2 bytes */
|
||||
uint32_t external_fa; /* external file attributes 4 bytes */
|
||||
|
||||
uint64_t disk_offset;
|
||||
} unz_file_info;
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
//
|
||||
// ZipArchive.h
|
||||
// ZipArchive
|
||||
//
|
||||
// Created by Serhii Mumriak on 12/1/15.
|
||||
//
|
||||
|
||||
#import <Foundation/Foundation.h>
|
||||
|
||||
//! Project version number for ZipArchive.
|
||||
FOUNDATION_EXPORT double ZipArchiveVersionNumber;
|
||||
|
||||
//! Project version string for ZipArchive.
|
||||
FOUNDATION_EXPORT const unsigned char ZipArchiveVersionString[];
|
||||
|
||||
// In this header, you should import all the public headers of your framework using statements like #import <SSZipArchive.h>
|
||||
|
||||
// This is to account for the many different ways this library gets imported.
|
||||
#if __has_include(<SSZipArchive/SSZipArchive.h>)
|
||||
#import <SSZipArchive/SSZipArchive.h>
|
||||
#elif __has_include("../SSZipArchive.h")
|
||||
#import "../SSZipArchive.h"
|
||||
#else
|
||||
#import "SSZipArchive.h"
|
||||
#endif
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
Condition of use and distribution are the same as zlib:
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgement in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
|
|
@ -0,0 +1,274 @@
|
|||
/* mz.h -- Errors codes, zip flags and magic
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
#ifndef MZ_H
|
||||
#define MZ_H
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
/* MZ_VERSION */
|
||||
#define MZ_VERSION ("3.0.4")
|
||||
#define MZ_VERSION_BUILD (030004)
|
||||
|
||||
/* MZ_ERROR */
|
||||
#define MZ_OK (0) /* zlib */
|
||||
#define MZ_STREAM_ERROR (-1) /* zlib */
|
||||
#define MZ_DATA_ERROR (-3) /* zlib */
|
||||
#define MZ_MEM_ERROR (-4) /* zlib */
|
||||
#define MZ_BUF_ERROR (-5) /* zlib */
|
||||
#define MZ_VERSION_ERROR (-6) /* zlib */
|
||||
|
||||
#define MZ_END_OF_LIST (-100)
|
||||
#define MZ_END_OF_STREAM (-101)
|
||||
|
||||
#define MZ_PARAM_ERROR (-102)
|
||||
#define MZ_FORMAT_ERROR (-103)
|
||||
#define MZ_INTERNAL_ERROR (-104)
|
||||
#define MZ_CRC_ERROR (-105)
|
||||
#define MZ_CRYPT_ERROR (-106)
|
||||
#define MZ_EXIST_ERROR (-107)
|
||||
#define MZ_PASSWORD_ERROR (-108)
|
||||
#define MZ_SUPPORT_ERROR (-109)
|
||||
#define MZ_HASH_ERROR (-110)
|
||||
#define MZ_OPEN_ERROR (-111)
|
||||
#define MZ_CLOSE_ERROR (-112)
|
||||
#define MZ_SEEK_ERROR (-113)
|
||||
#define MZ_TELL_ERROR (-114)
|
||||
#define MZ_READ_ERROR (-115)
|
||||
#define MZ_WRITE_ERROR (-116)
|
||||
#define MZ_SIGN_ERROR (-117)
|
||||
#define MZ_SYMLINK_ERROR (-118)
|
||||
|
||||
/* MZ_OPEN */
|
||||
#define MZ_OPEN_MODE_READ (0x01)
|
||||
#define MZ_OPEN_MODE_WRITE (0x02)
|
||||
#define MZ_OPEN_MODE_READWRITE (MZ_OPEN_MODE_READ | MZ_OPEN_MODE_WRITE)
|
||||
#define MZ_OPEN_MODE_APPEND (0x04)
|
||||
#define MZ_OPEN_MODE_CREATE (0x08)
|
||||
#define MZ_OPEN_MODE_EXISTING (0x10)
|
||||
|
||||
/* MZ_SEEK */
|
||||
#define MZ_SEEK_SET (0)
|
||||
#define MZ_SEEK_CUR (1)
|
||||
#define MZ_SEEK_END (2)
|
||||
|
||||
/* MZ_COMPRESS */
|
||||
#define MZ_COMPRESS_METHOD_STORE (0)
|
||||
#define MZ_COMPRESS_METHOD_DEFLATE (8)
|
||||
#define MZ_COMPRESS_METHOD_BZIP2 (12)
|
||||
#define MZ_COMPRESS_METHOD_LZMA (14)
|
||||
#define MZ_COMPRESS_METHOD_ZSTD (93)
|
||||
#define MZ_COMPRESS_METHOD_XZ (95)
|
||||
#define MZ_COMPRESS_METHOD_AES (99)
|
||||
|
||||
#define MZ_COMPRESS_LEVEL_DEFAULT (-1)
|
||||
#define MZ_COMPRESS_LEVEL_FAST (2)
|
||||
#define MZ_COMPRESS_LEVEL_NORMAL (6)
|
||||
#define MZ_COMPRESS_LEVEL_BEST (9)
|
||||
|
||||
/* MZ_ZIP_FLAG */
|
||||
#define MZ_ZIP_FLAG_ENCRYPTED (1 << 0)
|
||||
#define MZ_ZIP_FLAG_LZMA_EOS_MARKER (1 << 1)
|
||||
#define MZ_ZIP_FLAG_DEFLATE_MAX (1 << 1)
|
||||
#define MZ_ZIP_FLAG_DEFLATE_NORMAL (0)
|
||||
#define MZ_ZIP_FLAG_DEFLATE_FAST (1 << 2)
|
||||
#define MZ_ZIP_FLAG_DEFLATE_SUPER_FAST (MZ_ZIP_FLAG_DEFLATE_FAST | \
|
||||
MZ_ZIP_FLAG_DEFLATE_MAX)
|
||||
#define MZ_ZIP_FLAG_DATA_DESCRIPTOR (1 << 3)
|
||||
#define MZ_ZIP_FLAG_UTF8 (1 << 11)
|
||||
#define MZ_ZIP_FLAG_MASK_LOCAL_INFO (1 << 13)
|
||||
|
||||
/* MZ_ZIP_EXTENSION */
|
||||
#define MZ_ZIP_EXTENSION_ZIP64 (0x0001)
|
||||
#define MZ_ZIP_EXTENSION_NTFS (0x000a)
|
||||
#define MZ_ZIP_EXTENSION_AES (0x9901)
|
||||
#define MZ_ZIP_EXTENSION_UNIX1 (0x000d)
|
||||
#define MZ_ZIP_EXTENSION_SIGN (0x10c5)
|
||||
#define MZ_ZIP_EXTENSION_HASH (0x1a51)
|
||||
#define MZ_ZIP_EXTENSION_CDCD (0xcdcd)
|
||||
|
||||
/* MZ_ZIP64 */
|
||||
#define MZ_ZIP64_AUTO (0)
|
||||
#define MZ_ZIP64_FORCE (1)
|
||||
#define MZ_ZIP64_DISABLE (2)
|
||||
|
||||
/* MZ_HOST_SYSTEM */
|
||||
#define MZ_HOST_SYSTEM(VERSION_MADEBY) ((uint8_t)(VERSION_MADEBY >> 8))
|
||||
#define MZ_HOST_SYSTEM_MSDOS (0)
|
||||
#define MZ_HOST_SYSTEM_UNIX (3)
|
||||
#define MZ_HOST_SYSTEM_WINDOWS_NTFS (10)
|
||||
#define MZ_HOST_SYSTEM_RISCOS (13)
|
||||
#define MZ_HOST_SYSTEM_OSX_DARWIN (19)
|
||||
|
||||
/* MZ_PKCRYPT */
|
||||
#define MZ_PKCRYPT_HEADER_SIZE (12)
|
||||
|
||||
/* MZ_AES */
|
||||
#define MZ_AES_VERSION (1)
|
||||
#define MZ_AES_ENCRYPTION_MODE_128 (0x01)
|
||||
#define MZ_AES_ENCRYPTION_MODE_192 (0x02)
|
||||
#define MZ_AES_ENCRYPTION_MODE_256 (0x03)
|
||||
#define MZ_AES_KEY_LENGTH(MODE) (8 * (MODE & 3) + 8)
|
||||
#define MZ_AES_KEY_LENGTH_MAX (32)
|
||||
#define MZ_AES_BLOCK_SIZE (16)
|
||||
#define MZ_AES_HEADER_SIZE(MODE) ((4 * (MODE & 3) + 4) + 2)
|
||||
#define MZ_AES_FOOTER_SIZE (10)
|
||||
|
||||
/* MZ_HASH */
|
||||
#define MZ_HASH_MD5 (10)
|
||||
#define MZ_HASH_MD5_SIZE (16)
|
||||
#define MZ_HASH_SHA1 (20)
|
||||
#define MZ_HASH_SHA1_SIZE (20)
|
||||
#define MZ_HASH_SHA256 (23)
|
||||
#define MZ_HASH_SHA256_SIZE (32)
|
||||
#define MZ_HASH_MAX_SIZE (256)
|
||||
|
||||
/* MZ_ENCODING */
|
||||
#define MZ_ENCODING_CODEPAGE_437 (437)
|
||||
#define MZ_ENCODING_CODEPAGE_932 (932)
|
||||
#define MZ_ENCODING_CODEPAGE_936 (936)
|
||||
#define MZ_ENCODING_CODEPAGE_950 (950)
|
||||
#define MZ_ENCODING_UTF8 (65001)
|
||||
|
||||
/* MZ_UTILITY */
|
||||
#define MZ_UNUSED(SYMBOL) ((void)SYMBOL)
|
||||
|
||||
#ifndef MZ_CUSTOM_ALLOC
|
||||
#define MZ_ALLOC(SIZE) (malloc((SIZE)))
|
||||
#endif
|
||||
#ifndef MZ_CUSTOM_FREE
|
||||
#define MZ_FREE(PTR) (free(PTR))
|
||||
#endif
|
||||
|
||||
#if defined(_WIN32) && defined(MZ_EXPORTS)
|
||||
#define MZ_EXPORT __declspec(dllexport)
|
||||
#else
|
||||
#define MZ_EXPORT
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#include <stdlib.h> /* size_t, NULL, malloc */
|
||||
#include <time.h> /* time_t, time() */
|
||||
#include <string.h> /* memset, strncpy, strlen */
|
||||
#include <limits.h>
|
||||
|
||||
#if defined(HAVE_STDINT_H)
|
||||
# include <stdint.h>
|
||||
#elif defined(__has_include)
|
||||
# if __has_include(<stdint.h>)
|
||||
# include <stdint.h>
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef INT8_MAX
|
||||
typedef signed char int8_t;
|
||||
#endif
|
||||
#ifndef INT16_MAX
|
||||
typedef short int16_t;
|
||||
#endif
|
||||
#ifndef INT32_MAX
|
||||
typedef int int32_t;
|
||||
#endif
|
||||
#ifndef INT64_MAX
|
||||
typedef long long int64_t;
|
||||
#endif
|
||||
#ifndef UINT8_MAX
|
||||
typedef unsigned char uint8_t;
|
||||
#endif
|
||||
#ifndef UINT16_MAX
|
||||
typedef unsigned short uint16_t;
|
||||
#endif
|
||||
#ifndef UINT32_MAX
|
||||
typedef unsigned int uint32_t;
|
||||
#endif
|
||||
#ifndef UINT64_MAX
|
||||
typedef unsigned long long uint64_t;
|
||||
#endif
|
||||
|
||||
#if defined(HAVE_INTTYPES_H)
|
||||
# include <inttypes.h>
|
||||
#elif defined(__has_include)
|
||||
# if __has_include(<inttypes.h>)
|
||||
# include <inttypes.h>
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef PRId8
|
||||
# define PRId8 "hhd"
|
||||
#endif
|
||||
#ifndef PRIu8
|
||||
# define PRIu8 "hhu"
|
||||
#endif
|
||||
#ifndef PRIx8
|
||||
# define PRIx8 "hhx"
|
||||
#endif
|
||||
#ifndef PRId16
|
||||
# define PRId16 "hd"
|
||||
#endif
|
||||
#ifndef PRIu16
|
||||
# define PRIu16 "hu"
|
||||
#endif
|
||||
#ifndef PRIx16
|
||||
# define PRIx16 "hx"
|
||||
#endif
|
||||
#ifndef PRId32
|
||||
# define PRId32 "d"
|
||||
#endif
|
||||
#ifndef PRIu32
|
||||
# define PRIu32 "u"
|
||||
#endif
|
||||
#ifndef PRIx32
|
||||
# define PRIx32 "x"
|
||||
#endif
|
||||
#if ULONG_MAX == 0xfffffffful
|
||||
# ifndef PRId64
|
||||
# define PRId64 "ld"
|
||||
# endif
|
||||
# ifndef PRIu64
|
||||
# define PRIu64 "lu"
|
||||
# endif
|
||||
# ifndef PRIx64
|
||||
# define PRIx64 "lx"
|
||||
# endif
|
||||
#else
|
||||
# ifndef PRId64
|
||||
# define PRId64 "lld"
|
||||
# endif
|
||||
# ifndef PRIu64
|
||||
# define PRIu64 "llu"
|
||||
# endif
|
||||
# ifndef PRIx64
|
||||
# define PRIx64 "llx"
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef INT16_MAX
|
||||
# define INT16_MAX 32767
|
||||
#endif
|
||||
#ifndef INT32_MAX
|
||||
# define INT32_MAX 2147483647L
|
||||
#endif
|
||||
#ifndef INT64_MAX
|
||||
# define INT64_MAX 9223372036854775807LL
|
||||
#endif
|
||||
#ifndef UINT16_MAX
|
||||
# define UINT16_MAX 65535U
|
||||
#endif
|
||||
#ifndef UINT32_MAX
|
||||
# define UINT32_MAX 4294967295UL
|
||||
#endif
|
||||
#ifndef UINT64_MAX
|
||||
# define UINT64_MAX 18446744073709551615ULL
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,991 @@
|
|||
/* mz_compat.c -- Backwards compatible interface for older versions
|
||||
Version 2.8.9, July 4, 2019
|
||||
part of the MiniZip project
|
||||
|
||||
Copyright (C) 2010-2019 Nathan Moinvaziri
|
||||
https://github.com/nmoinvaz/minizip
|
||||
Copyright (C) 1998-2010 Gilles Vollant
|
||||
https://www.winimage.com/zLibDll/minizip.html
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
|
||||
#include "mz.h"
|
||||
#include "mz_os.h"
|
||||
#include "mz_strm.h"
|
||||
#include "mz_strm_mem.h"
|
||||
#include "mz_strm_os.h"
|
||||
#include "mz_strm_zlib.h"
|
||||
#include "mz_zip.h"
|
||||
|
||||
#include <stdio.h> /* SEEK */
|
||||
|
||||
#include "mz_compat.h"
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
typedef struct mz_compat_s {
|
||||
void *stream;
|
||||
void *handle;
|
||||
uint64_t entry_index;
|
||||
int64_t entry_pos;
|
||||
int64_t total_out;
|
||||
} mz_compat;
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
static int32_t zipConvertAppendToStreamMode(int append)
|
||||
{
|
||||
int32_t mode = MZ_OPEN_MODE_WRITE;
|
||||
switch (append)
|
||||
{
|
||||
case APPEND_STATUS_CREATE:
|
||||
mode |= MZ_OPEN_MODE_CREATE;
|
||||
break;
|
||||
case APPEND_STATUS_CREATEAFTER:
|
||||
mode |= MZ_OPEN_MODE_CREATE | MZ_OPEN_MODE_APPEND;
|
||||
break;
|
||||
case APPEND_STATUS_ADDINZIP:
|
||||
mode |= MZ_OPEN_MODE_READ | MZ_OPEN_MODE_APPEND;
|
||||
break;
|
||||
}
|
||||
return mode;
|
||||
}
|
||||
|
||||
zipFile zipOpen(const char *path, int append)
|
||||
{
|
||||
zlib_filefunc64_def pzlib = mz_stream_os_get_interface();
|
||||
return zipOpen2(path, append, NULL, &pzlib);
|
||||
}
|
||||
|
||||
zipFile zipOpen64(const void *path, int append)
|
||||
{
|
||||
zlib_filefunc64_def pzlib = mz_stream_os_get_interface();
|
||||
return zipOpen2(path, append, NULL, &pzlib);
|
||||
}
|
||||
|
||||
zipFile zipOpen2(const char *path, int append, const char **globalcomment,
|
||||
zlib_filefunc_def *pzlib_filefunc_def)
|
||||
{
|
||||
return zipOpen2_64(path, append, globalcomment, pzlib_filefunc_def);
|
||||
}
|
||||
|
||||
zipFile zipOpen2_64(const void *path, int append, const char **globalcomment,
|
||||
zlib_filefunc64_def *pzlib_filefunc_def)
|
||||
{
|
||||
zipFile zip = NULL;
|
||||
int32_t mode = zipConvertAppendToStreamMode(append);
|
||||
void *stream = NULL;
|
||||
|
||||
if (pzlib_filefunc_def)
|
||||
{
|
||||
if (mz_stream_create(&stream, (mz_stream_vtbl *)*pzlib_filefunc_def) == NULL)
|
||||
return NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (mz_stream_os_create(&stream) == NULL)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (mz_stream_open(stream, path, mode) != MZ_OK)
|
||||
{
|
||||
mz_stream_delete(&stream);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
zip = zipOpen_MZ(stream, append, globalcomment);
|
||||
|
||||
if (zip == NULL)
|
||||
{
|
||||
mz_stream_delete(&stream);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return zip;
|
||||
}
|
||||
|
||||
zipFile zipOpen_MZ(void *stream, int append, const char **globalcomment)
|
||||
{
|
||||
mz_compat *compat = NULL;
|
||||
int32_t err = MZ_OK;
|
||||
int32_t mode = zipConvertAppendToStreamMode(append);
|
||||
void *handle = NULL;
|
||||
|
||||
mz_zip_create(&handle);
|
||||
err = mz_zip_open(handle, stream, mode);
|
||||
|
||||
if (err != MZ_OK)
|
||||
{
|
||||
mz_zip_delete(&handle);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (globalcomment != NULL)
|
||||
mz_zip_get_comment(handle, globalcomment);
|
||||
|
||||
compat = (mz_compat *)MZ_ALLOC(sizeof(mz_compat));
|
||||
if (compat != NULL)
|
||||
{
|
||||
compat->handle = handle;
|
||||
compat->stream = stream;
|
||||
}
|
||||
else
|
||||
{
|
||||
mz_zip_delete(&handle);
|
||||
}
|
||||
|
||||
return (zipFile)compat;
|
||||
}
|
||||
|
||||
int zipOpenNewFileInZip5(zipFile file, const char *filename, const zip_fileinfo *zipfi,
|
||||
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
|
||||
uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level,
|
||||
int raw, int windowBits, int memLevel, int strategy, const char *password,
|
||||
signed char aes, uint16_t version_madeby, uint16_t flag_base, int zip64)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
mz_zip_file file_info;
|
||||
uint64_t dos_date = 0;
|
||||
|
||||
MZ_UNUSED(strategy);
|
||||
MZ_UNUSED(memLevel);
|
||||
MZ_UNUSED(windowBits);
|
||||
MZ_UNUSED(size_extrafield_local);
|
||||
MZ_UNUSED(extrafield_local);
|
||||
|
||||
if (compat == NULL)
|
||||
return ZIP_PARAMERROR;
|
||||
|
||||
memset(&file_info, 0, sizeof(file_info));
|
||||
|
||||
if (zipfi != NULL)
|
||||
{
|
||||
if (zipfi->mz_dos_date != 0)
|
||||
dos_date = zipfi->mz_dos_date;
|
||||
else
|
||||
dos_date = mz_zip_tm_to_dosdate(&zipfi->tmz_date);
|
||||
|
||||
file_info.modified_date = mz_zip_dosdate_to_time_t(dos_date);
|
||||
file_info.external_fa = zipfi->external_fa;
|
||||
file_info.internal_fa = zipfi->internal_fa;
|
||||
}
|
||||
|
||||
if (filename == NULL)
|
||||
filename = "-";
|
||||
|
||||
file_info.compression_method = compression_method;
|
||||
file_info.filename = filename;
|
||||
/* file_info.extrafield_local = extrafield_local; */
|
||||
/* file_info.extrafield_local_size = size_extrafield_local; */
|
||||
file_info.extrafield = extrafield_global;
|
||||
file_info.extrafield_size = size_extrafield_global;
|
||||
file_info.version_madeby = version_madeby;
|
||||
file_info.comment = comment;
|
||||
file_info.flag = flag_base;
|
||||
if (zip64)
|
||||
file_info.zip64 = MZ_ZIP64_FORCE;
|
||||
else
|
||||
file_info.zip64 = MZ_ZIP64_DISABLE;
|
||||
#ifdef HAVE_WZAES
|
||||
if ((aes && password != NULL) || (raw && (file_info.flag & MZ_ZIP_FLAG_ENCRYPTED)))
|
||||
file_info.aes_version = MZ_AES_VERSION;
|
||||
#endif
|
||||
|
||||
return mz_zip_entry_write_open(compat->handle, &file_info, (int16_t)level, (uint8_t)raw, password);
|
||||
}
|
||||
|
||||
int zipWriteInFileInZip(zipFile file, const void *buf, uint32_t len)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
int32_t written = 0;
|
||||
if (compat == NULL || len >= INT32_MAX)
|
||||
return ZIP_PARAMERROR;
|
||||
written = mz_zip_entry_write(compat->handle, buf, (int32_t)len);
|
||||
if ((written < 0) || ((uint32_t)written != len))
|
||||
return ZIP_ERRNO;
|
||||
return ZIP_OK;
|
||||
}
|
||||
|
||||
int zipCloseFileInZipRaw(zipFile file, uint32_t uncompressed_size, uint32_t crc32)
|
||||
{
|
||||
return zipCloseFileInZipRaw64(file, uncompressed_size, crc32);
|
||||
}
|
||||
|
||||
int zipCloseFileInZipRaw64(zipFile file, int64_t uncompressed_size, uint32_t crc32)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
if (compat == NULL)
|
||||
return ZIP_PARAMERROR;
|
||||
return mz_zip_entry_close_raw(compat->handle, uncompressed_size, crc32);
|
||||
}
|
||||
|
||||
int zipCloseFileInZip(zipFile file)
|
||||
{
|
||||
return zipCloseFileInZip64(file);
|
||||
}
|
||||
|
||||
int zipCloseFileInZip64(zipFile file)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
if (compat == NULL)
|
||||
return ZIP_PARAMERROR;
|
||||
return mz_zip_entry_close(compat->handle);
|
||||
}
|
||||
|
||||
int zipClose(zipFile file, const char *global_comment)
|
||||
{
|
||||
return zipClose_64(file, global_comment);
|
||||
}
|
||||
|
||||
int zipClose_64(zipFile file, const char *global_comment)
|
||||
{
|
||||
return zipClose2_64(file, global_comment, MZ_VERSION_MADEBY);
|
||||
}
|
||||
|
||||
int zipClose2_64(zipFile file, const char *global_comment, uint16_t version_madeby)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
if (compat->handle != NULL)
|
||||
err = zipClose2_MZ(file, global_comment, version_madeby);
|
||||
|
||||
if (compat->stream != NULL)
|
||||
{
|
||||
mz_stream_close(compat->stream);
|
||||
mz_stream_delete(&compat->stream);
|
||||
}
|
||||
|
||||
MZ_FREE(compat);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
/* Only closes the zip handle, does not close the stream */
|
||||
int zipClose_MZ(zipFile file, const char *global_comment)
|
||||
{
|
||||
return zipClose2_MZ(file, global_comment, MZ_VERSION_MADEBY);
|
||||
}
|
||||
|
||||
/* Only closes the zip handle, does not close the stream */
|
||||
int zipClose2_MZ(zipFile file, const char *global_comment, uint16_t version_madeby)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
if (compat == NULL)
|
||||
return ZIP_PARAMERROR;
|
||||
if (compat->handle == NULL)
|
||||
return err;
|
||||
|
||||
if (global_comment != NULL)
|
||||
mz_zip_set_comment(compat->handle, global_comment);
|
||||
|
||||
mz_zip_set_version_madeby(compat->handle, version_madeby);
|
||||
err = mz_zip_close(compat->handle);
|
||||
mz_zip_delete(&compat->handle);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
void* zipGetStream(zipFile file)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
if (compat == NULL)
|
||||
return NULL;
|
||||
return (void *)compat->stream;
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
unzFile unzOpen(const char *path)
|
||||
{
|
||||
return unzOpen64(path);
|
||||
}
|
||||
|
||||
unzFile unzOpen64(const void *path)
|
||||
{
|
||||
zlib_filefunc64_def pzlib = mz_stream_os_get_interface();
|
||||
return unzOpen2(path, &pzlib);
|
||||
}
|
||||
|
||||
unzFile unzOpen2(const char *path, zlib_filefunc_def *pzlib_filefunc_def)
|
||||
{
|
||||
return unzOpen2_64(path, pzlib_filefunc_def);
|
||||
}
|
||||
|
||||
unzFile unzOpen2_64(const void *path, zlib_filefunc64_def *pzlib_filefunc_def)
|
||||
{
|
||||
unzFile unz = NULL;
|
||||
void *stream = NULL;
|
||||
|
||||
if (pzlib_filefunc_def)
|
||||
{
|
||||
if (mz_stream_create(&stream, (mz_stream_vtbl *)*pzlib_filefunc_def) == NULL)
|
||||
return NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (mz_stream_os_create(&stream) == NULL)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (mz_stream_open(stream, path, MZ_OPEN_MODE_READ) != MZ_OK)
|
||||
{
|
||||
mz_stream_delete(&stream);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
unz = unzOpen_MZ(stream);
|
||||
if (unz == NULL)
|
||||
{
|
||||
mz_stream_delete(&stream);
|
||||
return NULL;
|
||||
}
|
||||
return unz;
|
||||
}
|
||||
|
||||
unzFile unzOpen_MZ(void *stream)
|
||||
{
|
||||
mz_compat *compat = NULL;
|
||||
int32_t err = MZ_OK;
|
||||
void *handle = NULL;
|
||||
|
||||
mz_zip_create(&handle);
|
||||
err = mz_zip_open(handle, stream, MZ_OPEN_MODE_READ);
|
||||
|
||||
if (err != MZ_OK)
|
||||
{
|
||||
mz_zip_delete(&handle);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
compat = (mz_compat *)MZ_ALLOC(sizeof(mz_compat));
|
||||
if (compat != NULL)
|
||||
{
|
||||
compat->handle = handle;
|
||||
compat->stream = stream;
|
||||
|
||||
mz_zip_goto_first_entry(compat->handle);
|
||||
}
|
||||
else
|
||||
{
|
||||
mz_zip_delete(&handle);
|
||||
}
|
||||
|
||||
return (unzFile)compat;
|
||||
}
|
||||
|
||||
int unzClose(unzFile file)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
if (compat == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
|
||||
if (compat->handle != NULL)
|
||||
err = unzClose_MZ(file);
|
||||
|
||||
if (compat->stream != NULL)
|
||||
{
|
||||
mz_stream_close(compat->stream);
|
||||
mz_stream_delete(&compat->stream);
|
||||
}
|
||||
|
||||
MZ_FREE(compat);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
/* Only closes the zip handle, does not close the stream */
|
||||
int unzClose_MZ(unzFile file)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
if (compat == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
|
||||
err = mz_zip_close(compat->handle);
|
||||
mz_zip_delete(&compat->handle);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
int unzGetGlobalInfo(unzFile file, unz_global_info* pglobal_info32)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
unz_global_info64 global_info64;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
memset(pglobal_info32, 0, sizeof(unz_global_info));
|
||||
if (compat == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
|
||||
err = unzGetGlobalInfo64(file, &global_info64);
|
||||
if (err == MZ_OK)
|
||||
{
|
||||
pglobal_info32->number_entry = (uint32_t)global_info64.number_entry;
|
||||
pglobal_info32->size_comment = global_info64.size_comment;
|
||||
pglobal_info32->number_disk_with_CD = global_info64.number_disk_with_CD;
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
int unzGetGlobalInfo64(unzFile file, unz_global_info64 *pglobal_info)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
const char *comment_ptr = NULL;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
memset(pglobal_info, 0, sizeof(unz_global_info64));
|
||||
if (compat == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
err = mz_zip_get_comment(compat->handle, &comment_ptr);
|
||||
if (err == MZ_OK)
|
||||
pglobal_info->size_comment = (uint16_t)strlen(comment_ptr);
|
||||
if ((err == MZ_OK) || (err == MZ_EXIST_ERROR))
|
||||
err = mz_zip_get_number_entry(compat->handle, &pglobal_info->number_entry);
|
||||
if (err == MZ_OK)
|
||||
err = mz_zip_get_disk_number_with_cd(compat->handle, &pglobal_info->number_disk_with_CD);
|
||||
return err;
|
||||
}
|
||||
|
||||
int unzGetGlobalComment(unzFile file, char *comment, uint16_t comment_size)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
const char *comment_ptr = NULL;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
if (comment == NULL || comment_size == 0)
|
||||
return UNZ_PARAMERROR;
|
||||
err = mz_zip_get_comment(compat->handle, &comment_ptr);
|
||||
if (err == MZ_OK)
|
||||
{
|
||||
strncpy(comment, comment_ptr, comment_size - 1);
|
||||
comment[comment_size - 1] = 0;
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
int unzOpenCurrentFile3(unzFile file, int *method, int *level, int raw, const char *password)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
mz_zip_file *file_info = NULL;
|
||||
int32_t err = MZ_OK;
|
||||
void *stream = NULL;
|
||||
|
||||
if (compat == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
if (method != NULL)
|
||||
*method = 0;
|
||||
if (level != NULL)
|
||||
*level = 0;
|
||||
|
||||
compat->total_out = 0;
|
||||
err = mz_zip_entry_read_open(compat->handle, (uint8_t)raw, password);
|
||||
if (err == MZ_OK)
|
||||
err = mz_zip_entry_get_info(compat->handle, &file_info);
|
||||
if (err == MZ_OK)
|
||||
{
|
||||
if (method != NULL)
|
||||
{
|
||||
*method = file_info->compression_method;
|
||||
}
|
||||
|
||||
if (level != NULL)
|
||||
{
|
||||
*level = 6;
|
||||
switch (file_info->flag & 0x06)
|
||||
{
|
||||
case MZ_ZIP_FLAG_DEFLATE_SUPER_FAST:
|
||||
*level = 1;
|
||||
break;
|
||||
case MZ_ZIP_FLAG_DEFLATE_FAST:
|
||||
*level = 2;
|
||||
break;
|
||||
case MZ_ZIP_FLAG_DEFLATE_MAX:
|
||||
*level = 9;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (err == MZ_OK)
|
||||
err = mz_zip_get_stream(compat->handle, &stream);
|
||||
if (err == MZ_OK)
|
||||
compat->entry_pos = mz_stream_tell(stream);
|
||||
return err;
|
||||
}
|
||||
|
||||
int unzOpenCurrentFile(unzFile file)
|
||||
{
|
||||
return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
|
||||
}
|
||||
|
||||
int unzOpenCurrentFilePassword(unzFile file, const char *password)
|
||||
{
|
||||
return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
|
||||
}
|
||||
|
||||
int unzOpenCurrentFile2(unzFile file, int *method, int *level, int raw)
|
||||
{
|
||||
return unzOpenCurrentFile3(file, method, level, raw, NULL);
|
||||
}
|
||||
|
||||
int unzReadCurrentFile(unzFile file, void *buf, uint32_t len)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
int32_t err = MZ_OK;
|
||||
if (compat == NULL || len >= INT32_MAX)
|
||||
return UNZ_PARAMERROR;
|
||||
err = mz_zip_entry_read(compat->handle, buf, (int32_t)len);
|
||||
if (err > 0)
|
||||
compat->total_out += (uint32_t)err;
|
||||
return err;
|
||||
}
|
||||
|
||||
int unzCloseCurrentFile(unzFile file)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
int32_t err = MZ_OK;
|
||||
if (compat == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
err = mz_zip_entry_close(compat->handle);
|
||||
return err;
|
||||
}
|
||||
|
||||
int unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filename,
|
||||
uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
mz_zip_file *file_info = NULL;
|
||||
uint16_t bytes_to_copy = 0;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
if (compat == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
|
||||
err = mz_zip_entry_get_info(compat->handle, &file_info);
|
||||
|
||||
if ((err == MZ_OK) && (pfile_info != NULL))
|
||||
{
|
||||
pfile_info->version = file_info->version_madeby;
|
||||
pfile_info->version_needed = file_info->version_needed;
|
||||
pfile_info->flag = file_info->flag;
|
||||
pfile_info->compression_method = file_info->compression_method;
|
||||
pfile_info->mz_dos_date = mz_zip_time_t_to_dos_date(file_info->modified_date);
|
||||
//mz_zip_time_t_to_tm(file_info->modified_date, &pfile_info->tmu_date);
|
||||
//pfile_info->tmu_date.tm_year += 1900;
|
||||
pfile_info->crc = file_info->crc;
|
||||
|
||||
pfile_info->size_filename = file_info->filename_size;
|
||||
pfile_info->size_file_extra = file_info->extrafield_size;
|
||||
pfile_info->size_file_comment = file_info->comment_size;
|
||||
|
||||
pfile_info->disk_num_start = (uint16_t)file_info->disk_number;
|
||||
pfile_info->internal_fa = file_info->internal_fa;
|
||||
pfile_info->external_fa = file_info->external_fa;
|
||||
|
||||
pfile_info->compressed_size = (uint32_t)file_info->compressed_size;
|
||||
pfile_info->uncompressed_size = (uint32_t)file_info->uncompressed_size;
|
||||
|
||||
if (filename_size > 0 && filename != NULL && file_info->filename != NULL)
|
||||
{
|
||||
bytes_to_copy = filename_size;
|
||||
if (bytes_to_copy > file_info->filename_size)
|
||||
bytes_to_copy = file_info->filename_size;
|
||||
memcpy(filename, file_info->filename, bytes_to_copy);
|
||||
if (bytes_to_copy < filename_size)
|
||||
filename[bytes_to_copy] = 0;
|
||||
}
|
||||
if (extrafield_size > 0 && extrafield != NULL)
|
||||
{
|
||||
bytes_to_copy = extrafield_size;
|
||||
if (bytes_to_copy > file_info->extrafield_size)
|
||||
bytes_to_copy = file_info->extrafield_size;
|
||||
memcpy(extrafield, file_info->extrafield, bytes_to_copy);
|
||||
}
|
||||
if (comment_size > 0 && comment != NULL && file_info->comment != NULL)
|
||||
{
|
||||
bytes_to_copy = comment_size;
|
||||
if (bytes_to_copy > file_info->comment_size)
|
||||
bytes_to_copy = file_info->comment_size;
|
||||
memcpy(comment, file_info->comment, bytes_to_copy);
|
||||
if (bytes_to_copy < comment_size)
|
||||
comment[bytes_to_copy] = 0;
|
||||
}
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
int unzGetCurrentFileInfo64(unzFile file, unz_file_info64 * pfile_info, char *filename,
|
||||
uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
mz_zip_file *file_info = NULL;
|
||||
uint16_t bytes_to_copy = 0;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
if (compat == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
|
||||
err = mz_zip_entry_get_info(compat->handle, &file_info);
|
||||
|
||||
if ((err == MZ_OK) && (pfile_info != NULL))
|
||||
{
|
||||
pfile_info->version = file_info->version_madeby;
|
||||
pfile_info->version_needed = file_info->version_needed;
|
||||
pfile_info->flag = file_info->flag;
|
||||
pfile_info->compression_method = file_info->compression_method;
|
||||
pfile_info->mz_dos_date = mz_zip_time_t_to_dos_date(file_info->modified_date);
|
||||
//mz_zip_time_t_to_tm(file_info->modified_date, &pfile_info->tmu_date);
|
||||
//pfile_info->tmu_date.tm_year += 1900;
|
||||
pfile_info->crc = file_info->crc;
|
||||
|
||||
pfile_info->size_filename = file_info->filename_size;
|
||||
pfile_info->size_file_extra = file_info->extrafield_size;
|
||||
pfile_info->size_file_comment = file_info->comment_size;
|
||||
|
||||
pfile_info->disk_num_start = file_info->disk_number;
|
||||
pfile_info->internal_fa = file_info->internal_fa;
|
||||
pfile_info->external_fa = file_info->external_fa;
|
||||
|
||||
pfile_info->compressed_size = (uint64_t)file_info->compressed_size;
|
||||
pfile_info->uncompressed_size = (uint64_t)file_info->uncompressed_size;
|
||||
|
||||
if (filename_size > 0 && filename != NULL && file_info->filename != NULL)
|
||||
{
|
||||
bytes_to_copy = filename_size;
|
||||
if (bytes_to_copy > file_info->filename_size)
|
||||
bytes_to_copy = file_info->filename_size;
|
||||
memcpy(filename, file_info->filename, bytes_to_copy);
|
||||
if (bytes_to_copy < filename_size)
|
||||
filename[bytes_to_copy] = 0;
|
||||
}
|
||||
|
||||
if (extrafield_size > 0 && extrafield != NULL)
|
||||
{
|
||||
bytes_to_copy = extrafield_size;
|
||||
if (bytes_to_copy > file_info->extrafield_size)
|
||||
bytes_to_copy = file_info->extrafield_size;
|
||||
memcpy(extrafield, file_info->extrafield, bytes_to_copy);
|
||||
}
|
||||
|
||||
if (comment_size > 0 && comment != NULL && file_info->comment != NULL)
|
||||
{
|
||||
bytes_to_copy = comment_size;
|
||||
if (bytes_to_copy > file_info->comment_size)
|
||||
bytes_to_copy = file_info->comment_size;
|
||||
memcpy(comment, file_info->comment, bytes_to_copy);
|
||||
if (bytes_to_copy < comment_size)
|
||||
comment[bytes_to_copy] = 0;
|
||||
}
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
int unzGoToFirstFile(unzFile file)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
if (compat == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
compat->entry_index = 0;
|
||||
return mz_zip_goto_first_entry(compat->handle);
|
||||
}
|
||||
|
||||
int unzGoToNextFile(unzFile file)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
int32_t err = MZ_OK;
|
||||
if (compat == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
err = mz_zip_goto_next_entry(compat->handle);
|
||||
if (err != MZ_END_OF_LIST)
|
||||
compat->entry_index += 1;
|
||||
return err;
|
||||
}
|
||||
|
||||
int unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filename_compare_func)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
mz_zip_file *file_info = NULL;
|
||||
uint64_t preserve_index = 0;
|
||||
int32_t err = MZ_OK;
|
||||
int32_t result = 0;
|
||||
|
||||
if (compat == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
|
||||
preserve_index = compat->entry_index;
|
||||
|
||||
err = mz_zip_goto_first_entry(compat->handle);
|
||||
while (err == MZ_OK)
|
||||
{
|
||||
err = mz_zip_entry_get_info(compat->handle, &file_info);
|
||||
if (err != MZ_OK)
|
||||
break;
|
||||
|
||||
if (filename_compare_func != NULL)
|
||||
result = filename_compare_func(file, filename, file_info->filename);
|
||||
else
|
||||
result = strcmp(filename, file_info->filename);
|
||||
|
||||
if (result == 0)
|
||||
return MZ_OK;
|
||||
|
||||
err = mz_zip_goto_next_entry(compat->handle);
|
||||
}
|
||||
|
||||
compat->entry_index = preserve_index;
|
||||
return err;
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int unzGetFilePos(unzFile file, unz_file_pos *file_pos)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
int32_t offset = 0;
|
||||
|
||||
if (compat == NULL || file_pos == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
|
||||
offset = unzGetOffset(file);
|
||||
if (offset < 0)
|
||||
return offset;
|
||||
|
||||
file_pos->pos_in_zip_directory = (uint32_t)offset;
|
||||
file_pos->num_of_file = (uint32_t)compat->entry_index;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int unzGoToFilePos(unzFile file, unz_file_pos *file_pos)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
unz64_file_pos file_pos64;
|
||||
|
||||
if (compat == NULL || file_pos == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
|
||||
file_pos64.pos_in_zip_directory = file_pos->pos_in_zip_directory;
|
||||
file_pos64.num_of_file = file_pos->num_of_file;
|
||||
|
||||
return unzGoToFilePos64(file, &file_pos64);
|
||||
}
|
||||
|
||||
int unzGetFilePos64(unzFile file, unz64_file_pos *file_pos)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
int64_t offset = 0;
|
||||
|
||||
if (compat == NULL || file_pos == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
|
||||
offset = unzGetOffset64(file);
|
||||
if (offset < 0)
|
||||
return (int)offset;
|
||||
|
||||
file_pos->pos_in_zip_directory = offset;
|
||||
file_pos->num_of_file = compat->entry_index;
|
||||
return UNZ_OK;
|
||||
}
|
||||
|
||||
int unzGoToFilePos64(unzFile file, const unz64_file_pos *file_pos)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
if (compat == NULL || file_pos == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
|
||||
err = mz_zip_goto_entry(compat->handle, file_pos->pos_in_zip_directory);
|
||||
if (err == MZ_OK)
|
||||
compat->entry_index = file_pos->num_of_file;
|
||||
return err;
|
||||
}
|
||||
|
||||
int32_t unzGetOffset(unzFile file)
|
||||
{
|
||||
return (int32_t)unzGetOffset64(file);
|
||||
}
|
||||
|
||||
int64_t unzGetOffset64(unzFile file)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
if (compat == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
return mz_zip_get_entry(compat->handle);
|
||||
}
|
||||
|
||||
int unzSetOffset(unzFile file, uint32_t pos)
|
||||
{
|
||||
return unzSetOffset64(file, pos);
|
||||
}
|
||||
|
||||
int unzSetOffset64(unzFile file, int64_t pos)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
if (compat == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
return (int)mz_zip_goto_entry(compat->handle, pos);
|
||||
}
|
||||
|
||||
int unzGetLocalExtrafield(unzFile file, void *buf, unsigned int len)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
mz_zip_file *file_info = NULL;
|
||||
int32_t err = MZ_OK;
|
||||
int32_t bytes_to_copy = 0;
|
||||
|
||||
if (compat == NULL || buf == NULL || len >= INT32_MAX)
|
||||
return UNZ_PARAMERROR;
|
||||
|
||||
err = mz_zip_entry_get_local_info(compat->handle, &file_info);
|
||||
if (err != MZ_OK)
|
||||
return err;
|
||||
|
||||
bytes_to_copy = (int32_t)len;
|
||||
if (bytes_to_copy > file_info->extrafield_size)
|
||||
bytes_to_copy = file_info->extrafield_size;
|
||||
|
||||
memcpy(buf, file_info->extrafield, bytes_to_copy);
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int64_t unztell(unzFile file)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
if (compat == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
return (int64_t)compat->total_out;
|
||||
}
|
||||
|
||||
int32_t unzTell(unzFile file)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
if (compat == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
return (int32_t)compat->total_out;
|
||||
}
|
||||
|
||||
int64_t unzTell64(unzFile file)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
if (compat == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
return (int64_t)compat->total_out;
|
||||
}
|
||||
|
||||
int unzSeek(unzFile file, int32_t offset, int origin)
|
||||
{
|
||||
return unzSeek64(file, offset, origin);
|
||||
}
|
||||
|
||||
int unzSeek64(unzFile file, int64_t offset, int origin)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
mz_zip_file *file_info = NULL;
|
||||
int64_t position = 0;
|
||||
int32_t err = MZ_OK;
|
||||
void *stream = NULL;
|
||||
|
||||
if (compat == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
err = mz_zip_entry_get_info(compat->handle, &file_info);
|
||||
if (err != MZ_OK)
|
||||
return err;
|
||||
if (file_info->compression_method != MZ_COMPRESS_METHOD_STORE)
|
||||
return UNZ_ERRNO;
|
||||
|
||||
if (origin == SEEK_SET)
|
||||
position = offset;
|
||||
else if (origin == SEEK_CUR)
|
||||
position = compat->total_out + offset;
|
||||
else if (origin == SEEK_END)
|
||||
position = (int64_t)file_info->compressed_size + offset;
|
||||
else
|
||||
return UNZ_PARAMERROR;
|
||||
|
||||
if (position > (int64_t)file_info->compressed_size)
|
||||
return UNZ_PARAMERROR;
|
||||
|
||||
err = mz_zip_get_stream(compat->handle, &stream);
|
||||
if (err == MZ_OK)
|
||||
err = mz_stream_seek(stream, compat->entry_pos + position, MZ_SEEK_SET);
|
||||
if (err == MZ_OK)
|
||||
compat->total_out = position;
|
||||
return err;
|
||||
}
|
||||
|
||||
int unzEndOfFile(unzFile file)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
mz_zip_file *file_info = NULL;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
if (compat == NULL)
|
||||
return UNZ_PARAMERROR;
|
||||
err = mz_zip_entry_get_info(compat->handle, &file_info);
|
||||
if (err != MZ_OK)
|
||||
return err;
|
||||
if (compat->total_out == (int64_t)file_info->uncompressed_size)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void* unzGetStream(unzFile file)
|
||||
{
|
||||
mz_compat *compat = (mz_compat *)file;
|
||||
if (compat == NULL)
|
||||
return NULL;
|
||||
return (void *)compat->stream;
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
void fill_fopen_filefunc(zlib_filefunc_def *pzlib_filefunc_def)
|
||||
{
|
||||
if (pzlib_filefunc_def != NULL)
|
||||
*pzlib_filefunc_def = mz_stream_os_get_interface();
|
||||
}
|
||||
|
||||
void fill_fopen64_filefunc(zlib_filefunc64_def *pzlib_filefunc_def)
|
||||
{
|
||||
if (pzlib_filefunc_def != NULL)
|
||||
*pzlib_filefunc_def = mz_stream_os_get_interface();
|
||||
}
|
||||
|
||||
void fill_win32_filefunc(zlib_filefunc_def *pzlib_filefunc_def)
|
||||
{
|
||||
if (pzlib_filefunc_def != NULL)
|
||||
*pzlib_filefunc_def = mz_stream_os_get_interface();
|
||||
}
|
||||
|
||||
void fill_win32_filefunc64(zlib_filefunc64_def *pzlib_filefunc_def)
|
||||
{
|
||||
if (pzlib_filefunc_def != NULL)
|
||||
*pzlib_filefunc_def = mz_stream_os_get_interface();
|
||||
}
|
||||
|
||||
void fill_win32_filefunc64A(zlib_filefunc64_def *pzlib_filefunc_def)
|
||||
{
|
||||
if (pzlib_filefunc_def != NULL)
|
||||
*pzlib_filefunc_def = mz_stream_os_get_interface();
|
||||
}
|
||||
|
||||
void fill_win32_filefunc64W(zlib_filefunc64_def *pzlib_filefunc_def)
|
||||
{
|
||||
/* NOTE: You should no longer pass in widechar string to open function */
|
||||
if (pzlib_filefunc_def != NULL)
|
||||
*pzlib_filefunc_def = mz_stream_os_get_interface();
|
||||
}
|
||||
|
||||
void fill_memory_filefunc(zlib_filefunc_def *pzlib_filefunc_def)
|
||||
{
|
||||
if (pzlib_filefunc_def != NULL)
|
||||
*pzlib_filefunc_def = mz_stream_mem_get_interface();
|
||||
}
|
||||
|
|
@ -0,0 +1,250 @@
|
|||
/* mz_compat.h -- Backwards compatible interface for older versions
|
||||
Version 2.8.6, April 8, 2019
|
||||
part of the MiniZip project
|
||||
|
||||
Copyright (C) 2010-2019 Nathan Moinvaziri
|
||||
https://github.com/nmoinvaz/minizip
|
||||
Copyright (C) 1998-2010 Gilles Vollant
|
||||
https://www.winimage.com/zLibDll/minizip.html
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
#ifndef MZ_COMPAT_H
|
||||
#define MZ_COMPAT_H
|
||||
|
||||
#include "mz.h"
|
||||
#include "../SSZipCommon.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#if defined(HAVE_ZLIB) && defined(MAX_MEM_LEVEL)
|
||||
#ifndef DEF_MEM_LEVEL
|
||||
# if MAX_MEM_LEVEL >= 8
|
||||
# define DEF_MEM_LEVEL 8
|
||||
# else
|
||||
# define DEF_MEM_LEVEL MAX_MEM_LEVEL
|
||||
# endif
|
||||
#endif
|
||||
#endif
|
||||
#ifndef MAX_WBITS
|
||||
#define MAX_WBITS 15
|
||||
#endif
|
||||
#ifndef DEF_MEM_LEVEL
|
||||
#define DEF_MEM_LEVEL 8
|
||||
#endif
|
||||
|
||||
#ifndef ZEXPORT
|
||||
# define ZEXPORT MZ_EXPORT
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
|
||||
/* like the STRICT of WIN32, we define a pointer that cannot be converted
|
||||
from (void*) without cast */
|
||||
typedef struct TagzipFile__ { int unused; } zip_file__;
|
||||
typedef zip_file__ *zipFile;
|
||||
#else
|
||||
typedef void *zipFile;
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
typedef void *zlib_filefunc_def;
|
||||
typedef void *zlib_filefunc64_def;
|
||||
typedef const char *zipcharpc;
|
||||
|
||||
typedef struct tm tm_unz;
|
||||
typedef struct tm tm_zip;
|
||||
|
||||
typedef uint64_t ZPOS64_T;
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
// ZipArchive 2.x uses dos_date
|
||||
#define MZ_COMPAT_VERSION 120
|
||||
|
||||
#if MZ_COMPAT_VERSION <= 110
|
||||
#define mz_dos_date dosDate
|
||||
#else
|
||||
#define mz_dos_date dos_date
|
||||
#endif
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint32_t mz_dos_date;
|
||||
struct tm tmz_date;
|
||||
uint16_t internal_fa; /* internal file attributes 2 bytes */
|
||||
uint32_t external_fa; /* external file attributes 4 bytes */
|
||||
} zip_fileinfo;
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#define ZIP_OK (0)
|
||||
#define ZIP_EOF (0)
|
||||
#define ZIP_ERRNO (-1)
|
||||
#define ZIP_PARAMERROR (-102)
|
||||
#define ZIP_BADZIPFILE (-103)
|
||||
#define ZIP_INTERNALERROR (-104)
|
||||
|
||||
#define Z_BZIP2ED (12)
|
||||
|
||||
#define APPEND_STATUS_CREATE (0)
|
||||
#define APPEND_STATUS_CREATEAFTER (1)
|
||||
#define APPEND_STATUS_ADDINZIP (2)
|
||||
|
||||
/***************************************************************************/
|
||||
/* Writing a zip file */
|
||||
|
||||
ZEXPORT zipFile zipOpen(const char *path, int append);
|
||||
ZEXPORT zipFile zipOpen64(const void *path, int append);
|
||||
ZEXPORT zipFile zipOpen2(const char *path, int append, const char **globalcomment,
|
||||
zlib_filefunc_def *pzlib_filefunc_def);
|
||||
ZEXPORT zipFile zipOpen2_64(const void *path, int append, const char **globalcomment,
|
||||
zlib_filefunc64_def *pzlib_filefunc_def);
|
||||
zipFile zipOpen_MZ(void *stream, int append, const char **globalcomment);
|
||||
|
||||
ZEXPORT int zipOpenNewFileInZip5(zipFile file, const char *filename, const zip_fileinfo *zipfi,
|
||||
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
|
||||
uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level,
|
||||
int raw, int windowBits, int memLevel, int strategy, const char *password,
|
||||
signed char aes, uint16_t version_madeby, uint16_t flag_base, int zip64);
|
||||
|
||||
ZEXPORT int zipWriteInFileInZip(zipFile file, const void *buf, uint32_t len);
|
||||
|
||||
ZEXPORT int zipCloseFileInZipRaw(zipFile file, uint32_t uncompressed_size, uint32_t crc32);
|
||||
ZEXPORT int zipCloseFileInZipRaw64(zipFile file, int64_t uncompressed_size, uint32_t crc32);
|
||||
ZEXPORT int zipCloseFileInZip(zipFile file);
|
||||
ZEXPORT int zipCloseFileInZip64(zipFile file);
|
||||
|
||||
ZEXPORT int zipClose(zipFile file, const char *global_comment);
|
||||
ZEXPORT int zipClose_64(zipFile file, const char *global_comment);
|
||||
ZEXPORT int zipClose2_64(zipFile file, const char *global_comment, uint16_t version_madeby);
|
||||
int zipClose_MZ(zipFile file, const char *global_comment);
|
||||
int zipClose2_MZ(zipFile file, const char *global_comment, uint16_t version_madeby);
|
||||
ZEXPORT void* zipGetStream(zipFile file);
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
|
||||
/* like the STRICT of WIN32, we define a pointer that cannot be converted
|
||||
from (void*) without cast */
|
||||
typedef struct TagunzFile__ { int unused; } unz_file__;
|
||||
typedef unz_file__ *unzFile;
|
||||
#else
|
||||
typedef void *unzFile;
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#define UNZ_OK (0)
|
||||
#define UNZ_END_OF_LIST_OF_FILE (-100)
|
||||
#define UNZ_ERRNO (-1)
|
||||
#define UNZ_EOF (0)
|
||||
#define UNZ_PARAMERROR (-102)
|
||||
#define UNZ_BADZIPFILE (-103)
|
||||
#define UNZ_INTERNALERROR (-104)
|
||||
#define UNZ_CRCERROR (-105)
|
||||
#define UNZ_BADPASSWORD (-106)
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
typedef int (*unzFileNameComparer)(unzFile file, const char *filename1, const char *filename2);
|
||||
typedef int (*unzIteratorFunction)(unzFile file);
|
||||
typedef int (*unzIteratorFunction2)(unzFile file, unz_file_info64 *pfile_info, char *filename,
|
||||
uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment,
|
||||
uint16_t comment_size);
|
||||
|
||||
/***************************************************************************/
|
||||
/* Reading a zip file */
|
||||
|
||||
ZEXPORT unzFile unzOpen(const char *path);
|
||||
ZEXPORT unzFile unzOpen64(const void *path);
|
||||
ZEXPORT unzFile unzOpen2(const char *path, zlib_filefunc_def *pzlib_filefunc_def);
|
||||
ZEXPORT unzFile unzOpen2_64(const void *path, zlib_filefunc64_def *pzlib_filefunc_def);
|
||||
unzFile unzOpen_MZ(void *stream);
|
||||
|
||||
ZEXPORT int unzClose(unzFile file);
|
||||
int unzClose_MZ(unzFile file);
|
||||
|
||||
ZEXPORT int unzGetGlobalInfo(unzFile file, unz_global_info* pglobal_info32);
|
||||
ZEXPORT int unzGetGlobalInfo64(unzFile file, unz_global_info64 *pglobal_info);
|
||||
ZEXPORT int unzGetGlobalComment(unzFile file, char *comment, uint16_t comment_size);
|
||||
|
||||
ZEXPORT int unzOpenCurrentFile(unzFile file);
|
||||
ZEXPORT int unzOpenCurrentFilePassword(unzFile file, const char *password);
|
||||
ZEXPORT int unzOpenCurrentFile2(unzFile file, int *method, int *level, int raw);
|
||||
ZEXPORT int unzOpenCurrentFile3(unzFile file, int *method, int *level, int raw, const char *password);
|
||||
ZEXPORT int unzReadCurrentFile(unzFile file, void *buf, uint32_t len);
|
||||
ZEXPORT int unzCloseCurrentFile(unzFile file);
|
||||
|
||||
|
||||
ZEXPORT int unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filename,
|
||||
uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment,
|
||||
uint16_t comment_size);
|
||||
ZEXPORT int unzGetCurrentFileInfo64(unzFile file, unz_file_info64 * pfile_info, char *filename,
|
||||
uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment,
|
||||
uint16_t comment_size);
|
||||
|
||||
ZEXPORT int unzGoToFirstFile(unzFile file);
|
||||
ZEXPORT int unzGoToNextFile(unzFile file);
|
||||
ZEXPORT int unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filename_compare_func);
|
||||
|
||||
ZEXPORT int unzGetLocalExtrafield(unzFile file, void *buf, unsigned int len);
|
||||
|
||||
/***************************************************************************/
|
||||
/* Raw access to zip file */
|
||||
|
||||
typedef struct unz_file_pos_s
|
||||
{
|
||||
uint32_t pos_in_zip_directory; /* offset in zip file directory */
|
||||
uint32_t num_of_file; /* # of file */
|
||||
} unz_file_pos;
|
||||
|
||||
ZEXPORT int unzGetFilePos(unzFile file, unz_file_pos *file_pos);
|
||||
ZEXPORT int unzGoToFilePos(unzFile file, unz_file_pos *file_pos);
|
||||
|
||||
typedef struct unz64_file_pos_s
|
||||
{
|
||||
int64_t pos_in_zip_directory; /* offset in zip file directory */
|
||||
uint64_t num_of_file; /* # of file */
|
||||
} unz64_file_pos;
|
||||
|
||||
ZEXPORT int unzGetFilePos64(unzFile file, unz64_file_pos *file_pos);
|
||||
ZEXPORT int unzGoToFilePos64(unzFile file, const unz64_file_pos *file_pos);
|
||||
|
||||
ZEXPORT int64_t unzGetOffset64(unzFile file);
|
||||
ZEXPORT int32_t unzGetOffset(unzFile file);
|
||||
ZEXPORT int unzSetOffset64(unzFile file, int64_t pos);
|
||||
ZEXPORT int unzSetOffset(unzFile file, uint32_t pos);
|
||||
ZEXPORT int64_t unztell(unzFile file);
|
||||
ZEXPORT int32_t unzTell(unzFile file);
|
||||
ZEXPORT int64_t unzTell64(unzFile file);
|
||||
ZEXPORT int unzSeek(unzFile file, int32_t offset, int origin);
|
||||
ZEXPORT int unzSeek64(unzFile file, int64_t offset, int origin);
|
||||
ZEXPORT int unzEndOfFile(unzFile file);
|
||||
ZEXPORT void* unzGetStream(unzFile file);
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
ZEXPORT void fill_fopen_filefunc(zlib_filefunc_def *pzlib_filefunc_def);
|
||||
ZEXPORT void fill_fopen64_filefunc(zlib_filefunc64_def *pzlib_filefunc_def);
|
||||
ZEXPORT void fill_win32_filefunc(zlib_filefunc_def *pzlib_filefunc_def);
|
||||
ZEXPORT void fill_win32_filefunc64(zlib_filefunc64_def *pzlib_filefunc_def);
|
||||
ZEXPORT void fill_win32_filefunc64A(zlib_filefunc64_def *pzlib_filefunc_def);
|
||||
ZEXPORT void fill_win32_filefunc64W(zlib_filefunc64_def *pzlib_filefunc_def);
|
||||
ZEXPORT void fill_memory_filefunc(zlib_filefunc_def *pzlib_filefunc_def);
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,196 @@
|
|||
/* mz_crypt.c -- Crypto/hash functions
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
|
||||
#include "mz.h"
|
||||
#include "mz_os.h"
|
||||
#include "mz_crypt.h"
|
||||
|
||||
#if defined(HAVE_ZLIB)
|
||||
# include "zlib.h"
|
||||
# if defined(ZLIBNG_VERNUM) && !defined(ZLIB_COMPAT)
|
||||
# include "zlib-ng.h"
|
||||
# endif
|
||||
#elif defined(HAVE_LZMA)
|
||||
# include "lzma.h"
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
/* Define z_crc_t in zlib 1.2.5 and less or if using zlib-ng */
|
||||
|
||||
#if defined(HAVE_ZLIB) && defined(ZLIBNG_VERNUM)
|
||||
# if defined(ZLIB_COMPAT)
|
||||
# define ZLIB_PREFIX(x) x
|
||||
# else
|
||||
# define ZLIB_PREFIX(x) zng_ ## x
|
||||
# endif
|
||||
typedef uint32_t z_crc_t;
|
||||
#elif defined(HAVE_ZLIB)
|
||||
# define ZLIB_PREFIX(x) x
|
||||
# if (ZLIB_VERNUM < 0x1270)
|
||||
typedef unsigned long z_crc_t;
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#if defined(MZ_ZIP_NO_CRYPTO)
|
||||
int32_t mz_crypt_rand(uint8_t *buf, int32_t size) {
|
||||
return mz_os_rand(buf, size);
|
||||
}
|
||||
#endif
|
||||
|
||||
uint32_t mz_crypt_crc32_update(uint32_t value, const uint8_t *buf, int32_t size) {
|
||||
#if defined(HAVE_ZLIB)
|
||||
return (uint32_t)ZLIB_PREFIX(crc32)((z_crc_t)value, buf, (uInt)size);
|
||||
#elif defined(HAVE_LZMA)
|
||||
return (uint32_t)lzma_crc32(buf, (size_t)size, (uint32_t)value);
|
||||
#else
|
||||
static uint32_t crc32_table[256] = {
|
||||
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
|
||||
0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
|
||||
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
|
||||
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
|
||||
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
|
||||
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
|
||||
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
|
||||
0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
|
||||
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
|
||||
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
|
||||
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
|
||||
0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
|
||||
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
|
||||
0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
|
||||
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
|
||||
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
|
||||
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
|
||||
0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
|
||||
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
|
||||
0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
|
||||
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
|
||||
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
|
||||
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
|
||||
0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
|
||||
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
|
||||
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
|
||||
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
|
||||
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
|
||||
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
|
||||
0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
|
||||
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
|
||||
0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
|
||||
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
|
||||
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
|
||||
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
|
||||
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
|
||||
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
|
||||
0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
|
||||
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
|
||||
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
|
||||
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
|
||||
0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
|
||||
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
|
||||
};
|
||||
value = ~value;
|
||||
|
||||
while (size > 0) {
|
||||
value = (value >> 8) ^ crc32_table[(value ^ *buf) & 0xFF];
|
||||
|
||||
buf += 1;
|
||||
size -= 1;
|
||||
}
|
||||
|
||||
return ~value;
|
||||
#endif
|
||||
}
|
||||
|
||||
#if defined(HAVE_WZAES)
|
||||
int32_t mz_crypt_pbkdf2(uint8_t *password, int32_t password_length, uint8_t *salt,
|
||||
int32_t salt_length, int32_t iteration_count, uint8_t *key, int32_t key_length) {
|
||||
void *hmac1 = NULL;
|
||||
void *hmac2 = NULL;
|
||||
void *hmac3 = NULL;
|
||||
int32_t err = MZ_OK;
|
||||
uint16_t i = 0;
|
||||
uint16_t j = 0;
|
||||
uint16_t k = 0;
|
||||
uint16_t block_count = 0;
|
||||
uint8_t uu[MZ_HASH_SHA1_SIZE];
|
||||
uint8_t ux[MZ_HASH_SHA1_SIZE];
|
||||
|
||||
if (password == NULL || salt == NULL || key == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
memset(key, 0, key_length);
|
||||
|
||||
mz_crypt_hmac_create(&hmac1);
|
||||
mz_crypt_hmac_create(&hmac2);
|
||||
mz_crypt_hmac_create(&hmac3);
|
||||
|
||||
mz_crypt_hmac_set_algorithm(hmac1, MZ_HASH_SHA1);
|
||||
mz_crypt_hmac_set_algorithm(hmac2, MZ_HASH_SHA1);
|
||||
mz_crypt_hmac_set_algorithm(hmac3, MZ_HASH_SHA1);
|
||||
|
||||
err = mz_crypt_hmac_init(hmac1, password, password_length);
|
||||
if (err == MZ_OK)
|
||||
err = mz_crypt_hmac_init(hmac2, password, password_length);
|
||||
if (err == MZ_OK)
|
||||
err = mz_crypt_hmac_update(hmac2, salt, salt_length);
|
||||
|
||||
block_count = 1 + ((uint16_t)key_length - 1) / MZ_HASH_SHA1_SIZE;
|
||||
|
||||
for (i = 0; (err == MZ_OK) && (i < block_count); i += 1) {
|
||||
memset(ux, 0, sizeof(ux));
|
||||
|
||||
err = mz_crypt_hmac_copy(hmac2, hmac3);
|
||||
if (err != MZ_OK)
|
||||
break;
|
||||
|
||||
uu[0] = (uint8_t)((i + 1) >> 24);
|
||||
uu[1] = (uint8_t)((i + 1) >> 16);
|
||||
uu[2] = (uint8_t)((i + 1) >> 8);
|
||||
uu[3] = (uint8_t)(i + 1);
|
||||
|
||||
for (j = 0, k = 4; j < iteration_count; j += 1) {
|
||||
err = mz_crypt_hmac_update(hmac3, uu, k);
|
||||
if (err == MZ_OK)
|
||||
err = mz_crypt_hmac_end(hmac3, uu, sizeof(uu));
|
||||
if (err != MZ_OK)
|
||||
break;
|
||||
|
||||
for(k = 0; k < MZ_HASH_SHA1_SIZE; k += 1)
|
||||
ux[k] ^= uu[k];
|
||||
|
||||
err = mz_crypt_hmac_copy(hmac1, hmac3);
|
||||
if (err != MZ_OK)
|
||||
break;
|
||||
}
|
||||
|
||||
if (err != MZ_OK)
|
||||
break;
|
||||
|
||||
j = 0;
|
||||
k = i * MZ_HASH_SHA1_SIZE;
|
||||
|
||||
while (j < MZ_HASH_SHA1_SIZE && k < key_length)
|
||||
key[k++] = ux[j++];
|
||||
}
|
||||
|
||||
/* hmac3 uses the same provider as hmac2, so it must be deleted
|
||||
before the context is destroyed. */
|
||||
mz_crypt_hmac_delete(&hmac3);
|
||||
mz_crypt_hmac_delete(&hmac1);
|
||||
mz_crypt_hmac_delete(&hmac2);
|
||||
|
||||
return err;
|
||||
}
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
/* mz_crypt.h -- Crypto/hash functions
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
#ifndef MZ_CRYPT_H
|
||||
#define MZ_CRYPT_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
uint32_t mz_crypt_crc32_update(uint32_t value, const uint8_t *buf, int32_t size);
|
||||
|
||||
int32_t mz_crypt_pbkdf2(uint8_t *password, int32_t password_length, uint8_t *salt,
|
||||
int32_t salt_length, int32_t iteration_count, uint8_t *key, int32_t key_length);
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_crypt_rand(uint8_t *buf, int32_t size);
|
||||
|
||||
void mz_crypt_sha_reset(void *handle);
|
||||
int32_t mz_crypt_sha_begin(void *handle);
|
||||
int32_t mz_crypt_sha_update(void *handle, const void *buf, int32_t size);
|
||||
int32_t mz_crypt_sha_end(void *handle, uint8_t *digest, int32_t digest_size);
|
||||
void mz_crypt_sha_set_algorithm(void *handle, uint16_t algorithm);
|
||||
void* mz_crypt_sha_create(void **handle);
|
||||
void mz_crypt_sha_delete(void **handle);
|
||||
|
||||
void mz_crypt_aes_reset(void *handle);
|
||||
int32_t mz_crypt_aes_encrypt(void *handle, uint8_t *buf, int32_t size);
|
||||
int32_t mz_crypt_aes_decrypt(void *handle, uint8_t *buf, int32_t size);
|
||||
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length);
|
||||
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length);
|
||||
void mz_crypt_aes_set_mode(void *handle, int32_t mode);
|
||||
void* mz_crypt_aes_create(void **handle);
|
||||
void mz_crypt_aes_delete(void **handle);
|
||||
|
||||
void mz_crypt_hmac_reset(void *handle);
|
||||
int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length);
|
||||
int32_t mz_crypt_hmac_update(void *handle, const void *buf, int32_t size);
|
||||
int32_t mz_crypt_hmac_end(void *handle, uint8_t *digest, int32_t digest_size);
|
||||
int32_t mz_crypt_hmac_copy(void *src_handle, void *target_handle);
|
||||
void mz_crypt_hmac_set_algorithm(void *handle, uint16_t algorithm);
|
||||
void* mz_crypt_hmac_create(void **handle);
|
||||
void mz_crypt_hmac_delete(void **handle);
|
||||
|
||||
int32_t mz_crypt_sign(uint8_t *message, int32_t message_size, uint8_t *cert_data, int32_t cert_data_size,
|
||||
const char *cert_pwd, uint8_t **signature, int32_t *signature_size);
|
||||
int32_t mz_crypt_sign_verify(uint8_t *message, int32_t message_size, uint8_t *signature, int32_t signature_size);
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,487 @@
|
|||
/* mz_crypt_apple.c -- Crypto/hash functions for Apple
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
|
||||
#include "mz.h"
|
||||
|
||||
#include <CoreFoundation/CoreFoundation.h>
|
||||
#include <CommonCrypto/CommonCryptor.h>
|
||||
#include <CommonCrypto/CommonDigest.h>
|
||||
#include <CommonCrypto/CommonHMAC.h>
|
||||
#include <Security/Security.h>
|
||||
#include <Security/SecPolicy.h>
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_crypt_rand(uint8_t *buf, int32_t size) {
|
||||
if (SecRandomCopyBytes(kSecRandomDefault, size, buf) != errSecSuccess)
|
||||
return 0;
|
||||
return size;
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
typedef struct mz_crypt_sha_s {
|
||||
CC_SHA1_CTX ctx1;
|
||||
CC_SHA256_CTX ctx256;
|
||||
int32_t error;
|
||||
int32_t initialized;
|
||||
uint16_t algorithm;
|
||||
} mz_crypt_sha;
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
void mz_crypt_sha_reset(void *handle) {
|
||||
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
|
||||
|
||||
sha->error = 0;
|
||||
sha->initialized = 0;
|
||||
}
|
||||
|
||||
int32_t mz_crypt_sha_begin(void *handle) {
|
||||
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
|
||||
|
||||
if (sha == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
mz_crypt_sha_reset(handle);
|
||||
|
||||
if (sha->algorithm == MZ_HASH_SHA1)
|
||||
sha->error = CC_SHA1_Init(&sha->ctx1);
|
||||
else if (sha->algorithm == MZ_HASH_SHA256)
|
||||
sha->error = CC_SHA256_Init(&sha->ctx256);
|
||||
else
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
if (!sha->error)
|
||||
return MZ_HASH_ERROR;
|
||||
|
||||
sha->initialized = 1;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_crypt_sha_update(void *handle, const void *buf, int32_t size) {
|
||||
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
|
||||
|
||||
if (sha == NULL || buf == NULL || !sha->initialized)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
if (sha->algorithm == MZ_HASH_SHA1)
|
||||
sha->error = CC_SHA1_Update(&sha->ctx1, buf, size);
|
||||
else
|
||||
sha->error = CC_SHA256_Update(&sha->ctx256, buf, size);
|
||||
|
||||
if (!sha->error)
|
||||
return MZ_HASH_ERROR;
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
int32_t mz_crypt_sha_end(void *handle, uint8_t *digest, int32_t digest_size) {
|
||||
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
|
||||
|
||||
if (sha == NULL || digest == NULL || !sha->initialized)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
if (sha->algorithm == MZ_HASH_SHA1) {
|
||||
if (digest_size < MZ_HASH_SHA1_SIZE)
|
||||
return MZ_BUF_ERROR;
|
||||
sha->error = CC_SHA1_Final(digest, &sha->ctx1);
|
||||
} else {
|
||||
if (digest_size < MZ_HASH_SHA256_SIZE)
|
||||
return MZ_BUF_ERROR;
|
||||
sha->error = CC_SHA256_Final(digest, &sha->ctx256);
|
||||
}
|
||||
|
||||
if (!sha->error)
|
||||
return MZ_HASH_ERROR;
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
void mz_crypt_sha_set_algorithm(void *handle, uint16_t algorithm) {
|
||||
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
|
||||
sha->algorithm = algorithm;
|
||||
}
|
||||
|
||||
void *mz_crypt_sha_create(void **handle) {
|
||||
mz_crypt_sha *sha = NULL;
|
||||
|
||||
sha = (mz_crypt_sha *)MZ_ALLOC(sizeof(mz_crypt_sha));
|
||||
if (sha != NULL) {
|
||||
memset(sha, 0, sizeof(mz_crypt_sha));
|
||||
sha->algorithm = MZ_HASH_SHA256;
|
||||
}
|
||||
if (handle != NULL)
|
||||
*handle = sha;
|
||||
|
||||
return sha;
|
||||
}
|
||||
|
||||
void mz_crypt_sha_delete(void **handle) {
|
||||
mz_crypt_sha *sha = NULL;
|
||||
if (handle == NULL)
|
||||
return;
|
||||
sha = (mz_crypt_sha *)*handle;
|
||||
if (sha != NULL) {
|
||||
mz_crypt_sha_reset(*handle);
|
||||
MZ_FREE(sha);
|
||||
}
|
||||
*handle = NULL;
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
typedef struct mz_crypt_aes_s {
|
||||
CCCryptorRef crypt;
|
||||
int32_t mode;
|
||||
int32_t error;
|
||||
} mz_crypt_aes;
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
void mz_crypt_aes_reset(void *handle) {
|
||||
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
|
||||
|
||||
if (aes->crypt != NULL)
|
||||
CCCryptorRelease(aes->crypt);
|
||||
aes->crypt = NULL;
|
||||
}
|
||||
|
||||
int32_t mz_crypt_aes_encrypt(void *handle, uint8_t *buf, int32_t size) {
|
||||
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
|
||||
size_t data_moved = 0;
|
||||
|
||||
if (aes == NULL || buf == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
if (size != MZ_AES_BLOCK_SIZE)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
aes->error = CCCryptorUpdate(aes->crypt, buf, size, buf, size, &data_moved);
|
||||
|
||||
if (aes->error != kCCSuccess)
|
||||
return MZ_HASH_ERROR;
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
int32_t mz_crypt_aes_decrypt(void *handle, uint8_t *buf, int32_t size) {
|
||||
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
|
||||
size_t data_moved = 0;
|
||||
|
||||
if (aes == NULL || buf == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
if (size != MZ_AES_BLOCK_SIZE)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
aes->error = CCCryptorUpdate(aes->crypt, buf, size, buf, size, &data_moved);
|
||||
|
||||
if (aes->error != kCCSuccess)
|
||||
return MZ_HASH_ERROR;
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length) {
|
||||
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
|
||||
|
||||
|
||||
if (aes == NULL || key == NULL || key_length == 0)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
mz_crypt_aes_reset(handle);
|
||||
|
||||
aes->error = CCCryptorCreate(kCCEncrypt, kCCAlgorithmAES, kCCOptionECBMode,
|
||||
key, key_length, NULL, &aes->crypt);
|
||||
|
||||
if (aes->error != kCCSuccess)
|
||||
return MZ_HASH_ERROR;
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length) {
|
||||
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
|
||||
|
||||
|
||||
if (aes == NULL || key == NULL || key_length == 0)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
mz_crypt_aes_reset(handle);
|
||||
|
||||
aes->error = CCCryptorCreate(kCCDecrypt, kCCAlgorithmAES, kCCOptionECBMode,
|
||||
key, key_length, NULL, &aes->crypt);
|
||||
|
||||
if (aes->error != kCCSuccess)
|
||||
return MZ_HASH_ERROR;
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
void mz_crypt_aes_set_mode(void *handle, int32_t mode) {
|
||||
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
|
||||
aes->mode = mode;
|
||||
}
|
||||
|
||||
void *mz_crypt_aes_create(void **handle) {
|
||||
mz_crypt_aes *aes = NULL;
|
||||
|
||||
aes = (mz_crypt_aes *)MZ_ALLOC(sizeof(mz_crypt_aes));
|
||||
if (aes != NULL)
|
||||
memset(aes, 0, sizeof(mz_crypt_aes));
|
||||
if (handle != NULL)
|
||||
*handle = aes;
|
||||
|
||||
return aes;
|
||||
}
|
||||
|
||||
void mz_crypt_aes_delete(void **handle) {
|
||||
mz_crypt_aes *aes = NULL;
|
||||
if (handle == NULL)
|
||||
return;
|
||||
aes = (mz_crypt_aes *)*handle;
|
||||
if (aes != NULL) {
|
||||
mz_crypt_aes_reset(*handle);
|
||||
MZ_FREE(aes);
|
||||
}
|
||||
*handle = NULL;
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
typedef struct mz_crypt_hmac_s {
|
||||
CCHmacContext ctx;
|
||||
int32_t initialized;
|
||||
int32_t error;
|
||||
uint16_t algorithm;
|
||||
} mz_crypt_hmac;
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
static void mz_crypt_hmac_free(void *handle) {
|
||||
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
|
||||
memset(&hmac->ctx, 0, sizeof(hmac->ctx));
|
||||
}
|
||||
|
||||
void mz_crypt_hmac_reset(void *handle) {
|
||||
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
|
||||
mz_crypt_hmac_free(handle);
|
||||
hmac->error = 0;
|
||||
}
|
||||
|
||||
int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length) {
|
||||
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
|
||||
CCHmacAlgorithm algorithm = 0;
|
||||
|
||||
if (hmac == NULL || key == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
mz_crypt_hmac_reset(handle);
|
||||
|
||||
if (hmac->algorithm == MZ_HASH_SHA1)
|
||||
algorithm = kCCHmacAlgSHA1;
|
||||
else if (hmac->algorithm == MZ_HASH_SHA256)
|
||||
algorithm = kCCHmacAlgSHA256;
|
||||
else
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
CCHmacInit(&hmac->ctx, algorithm, key, key_length);
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_crypt_hmac_update(void *handle, const void *buf, int32_t size) {
|
||||
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
|
||||
|
||||
if (hmac == NULL || buf == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
CCHmacUpdate(&hmac->ctx, buf, size);
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_crypt_hmac_end(void *handle, uint8_t *digest, int32_t digest_size) {
|
||||
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
|
||||
|
||||
if (hmac == NULL || digest == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
if (hmac->algorithm == MZ_HASH_SHA1) {
|
||||
if (digest_size < MZ_HASH_SHA1_SIZE)
|
||||
return MZ_BUF_ERROR;
|
||||
CCHmacFinal(&hmac->ctx, digest);
|
||||
} else {
|
||||
if (digest_size < MZ_HASH_SHA256_SIZE)
|
||||
return MZ_BUF_ERROR;
|
||||
CCHmacFinal(&hmac->ctx, digest);
|
||||
}
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
void mz_crypt_hmac_set_algorithm(void *handle, uint16_t algorithm) {
|
||||
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
|
||||
hmac->algorithm = algorithm;
|
||||
}
|
||||
|
||||
int32_t mz_crypt_hmac_copy(void *src_handle, void *target_handle) {
|
||||
mz_crypt_hmac *source = (mz_crypt_hmac *)src_handle;
|
||||
mz_crypt_hmac *target = (mz_crypt_hmac *)target_handle;
|
||||
|
||||
if (source == NULL || target == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
memcpy(&target->ctx, &source->ctx, sizeof(CCHmacContext));
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
void *mz_crypt_hmac_create(void **handle) {
|
||||
mz_crypt_hmac *hmac = NULL;
|
||||
|
||||
hmac = (mz_crypt_hmac *)MZ_ALLOC(sizeof(mz_crypt_hmac));
|
||||
if (hmac != NULL) {
|
||||
memset(hmac, 0, sizeof(mz_crypt_hmac));
|
||||
hmac->algorithm = MZ_HASH_SHA256;
|
||||
}
|
||||
if (handle != NULL)
|
||||
*handle = hmac;
|
||||
|
||||
return hmac;
|
||||
}
|
||||
|
||||
void mz_crypt_hmac_delete(void **handle) {
|
||||
mz_crypt_hmac *hmac = NULL;
|
||||
if (handle == NULL)
|
||||
return;
|
||||
hmac = (mz_crypt_hmac *)*handle;
|
||||
if (hmac != NULL) {
|
||||
mz_crypt_hmac_free(*handle);
|
||||
MZ_FREE(hmac);
|
||||
}
|
||||
*handle = NULL;
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#if defined(MZ_ZIP_SIGNING)
|
||||
int32_t mz_crypt_sign(uint8_t *message, int32_t message_size, uint8_t *cert_data, int32_t cert_data_size,
|
||||
const char *cert_pwd, uint8_t **signature, int32_t *signature_size) {
|
||||
CFStringRef password_ref = NULL;
|
||||
CFDictionaryRef options_dict = NULL;
|
||||
CFDictionaryRef identity_trust = NULL;
|
||||
CFDataRef signature_out = NULL;
|
||||
CFDataRef pkcs12_data = NULL;
|
||||
CFArrayRef items = 0;
|
||||
SecIdentityRef identity = NULL;
|
||||
SecTrustRef trust = NULL;
|
||||
OSStatus status = noErr;
|
||||
const void *options_key[2] = { kSecImportExportPassphrase, kSecReturnRef };
|
||||
const void *options_values[2] = { 0, kCFBooleanTrue };
|
||||
int32_t err = MZ_SIGN_ERROR;
|
||||
|
||||
|
||||
if (message == NULL || cert_data == NULL || signature == NULL || signature_size == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
*signature = NULL;
|
||||
*signature_size = 0;
|
||||
|
||||
password_ref = CFStringCreateWithCString(0, cert_pwd, kCFStringEncodingUTF8);
|
||||
options_values[0] = password_ref;
|
||||
|
||||
options_dict = CFDictionaryCreate(0, options_key, options_values, 2, 0, 0);
|
||||
if (options_dict)
|
||||
pkcs12_data = CFDataCreate(0, cert_data, cert_data_size);
|
||||
if (pkcs12_data)
|
||||
status = SecPKCS12Import(pkcs12_data, options_dict, &items);
|
||||
if (status == noErr)
|
||||
identity_trust = CFArrayGetValueAtIndex(items, 0);
|
||||
if (identity_trust)
|
||||
identity = (SecIdentityRef)CFDictionaryGetValue(identity_trust, kSecImportItemIdentity);
|
||||
if (identity)
|
||||
trust = (SecTrustRef)CFDictionaryGetValue(identity_trust, kSecImportItemTrust);
|
||||
if (trust) {
|
||||
status = CMSEncodeContent(identity, NULL, NULL, FALSE, 0, message, message_size, &signature_out);
|
||||
|
||||
if (status == errSecSuccess) {
|
||||
*signature_size = CFDataGetLength(signature_out);
|
||||
*signature = (uint8_t *)MZ_ALLOC(*signature_size);
|
||||
|
||||
memcpy(*signature, CFDataGetBytePtr(signature_out), *signature_size);
|
||||
|
||||
err = MZ_OK;
|
||||
}
|
||||
}
|
||||
|
||||
if (signature_out)
|
||||
CFRelease(signature_out);
|
||||
if (items)
|
||||
CFRelease(items);
|
||||
if (pkcs12_data)
|
||||
CFRelease(pkcs12_data);
|
||||
if (options_dict)
|
||||
CFRelease(options_dict);
|
||||
if (password_ref)
|
||||
CFRelease(password_ref);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
int32_t mz_crypt_sign_verify(uint8_t *message, int32_t message_size, uint8_t *signature, int32_t signature_size) {
|
||||
CMSDecoderRef decoder = NULL;
|
||||
CMSSignerStatus signer_status = 0;
|
||||
CFDataRef message_out = NULL;
|
||||
SecPolicyRef trust_policy = NULL;
|
||||
OSStatus status = noErr;
|
||||
OSStatus verify_status = noErr;
|
||||
size_t signer_count = 0;
|
||||
size_t i = 0;
|
||||
int32_t err = MZ_SIGN_ERROR;
|
||||
|
||||
if (message == NULL || signature == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
status = CMSDecoderCreate(&decoder);
|
||||
if (status == errSecSuccess)
|
||||
status = CMSDecoderUpdateMessage(decoder, signature, signature_size);
|
||||
if (status == errSecSuccess)
|
||||
status = CMSDecoderFinalizeMessage(decoder);
|
||||
if (status == errSecSuccess)
|
||||
trust_policy = SecPolicyCreateBasicX509();
|
||||
|
||||
if (status == errSecSuccess && trust_policy) {
|
||||
CMSDecoderGetNumSigners(decoder, &signer_count);
|
||||
if (signer_count > 0)
|
||||
err = MZ_OK;
|
||||
for (i = 0; i < signer_count; i += 1) {
|
||||
status = CMSDecoderCopySignerStatus(decoder, i, trust_policy, TRUE, &signer_status, NULL, &verify_status);
|
||||
if (status != errSecSuccess || verify_status != 0 || signer_status != kCMSSignerValid) {
|
||||
err = MZ_SIGN_ERROR;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (err == MZ_OK) {
|
||||
status = CMSDecoderCopyContent(decoder, &message_out);
|
||||
if ((status != errSecSuccess) ||
|
||||
(CFDataGetLength(message_out) != message_size) ||
|
||||
(memcmp(message, CFDataGetBytePtr(message_out), message_size) != 0))
|
||||
err = MZ_SIGN_ERROR;
|
||||
}
|
||||
|
||||
if (trust_policy)
|
||||
CFRelease(trust_policy);
|
||||
if (decoder)
|
||||
CFRelease(decoder);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,354 @@
|
|||
/* mz_os.c -- System functions
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
Copyright (C) 1998-2010 Gilles Vollant
|
||||
https://www.winimage.com/zLibDll/minizip.html
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
#include "mz.h"
|
||||
#include "mz_crypt.h"
|
||||
#include "mz_os.h"
|
||||
#include "mz_strm.h"
|
||||
#include "mz_strm_os.h"
|
||||
|
||||
#include <ctype.h> /* tolower */
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_path_combine(char *path, const char *join, int32_t max_path) {
|
||||
int32_t path_len = 0;
|
||||
|
||||
if (path == NULL || join == NULL || max_path == 0)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
path_len = (int32_t)strlen(path);
|
||||
|
||||
if (path_len == 0) {
|
||||
strncpy(path, join, max_path - 1);
|
||||
path[max_path - 1] = 0;
|
||||
} else {
|
||||
mz_path_append_slash(path, max_path, MZ_PATH_SLASH_PLATFORM);
|
||||
strncat(path, join, max_path - path_len);
|
||||
}
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_path_append_slash(char *path, int32_t max_path, char slash) {
|
||||
int32_t path_len = (int32_t)strlen(path);
|
||||
if ((path_len + 2) >= max_path)
|
||||
return MZ_BUF_ERROR;
|
||||
if (path[path_len - 1] != '\\' && path[path_len - 1] != '/') {
|
||||
path[path_len] = slash;
|
||||
path[path_len + 1] = 0;
|
||||
}
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_path_remove_slash(char *path) {
|
||||
int32_t path_len = (int32_t)strlen(path);
|
||||
while (path_len > 0) {
|
||||
if (path[path_len - 1] == '\\' || path[path_len - 1] == '/')
|
||||
path[path_len - 1] = 0;
|
||||
else
|
||||
break;
|
||||
|
||||
path_len -= 1;
|
||||
}
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_path_has_slash(const char *path) {
|
||||
int32_t path_len = (int32_t)strlen(path);
|
||||
if (path[path_len - 1] != '\\' && path[path_len - 1] != '/')
|
||||
return MZ_EXIST_ERROR;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_path_convert_slashes(char *path, char slash) {
|
||||
int32_t i = 0;
|
||||
|
||||
for (i = 0; i < (int32_t)strlen(path); i += 1) {
|
||||
if (path[i] == '\\' || path[i] == '/')
|
||||
path[i] = slash;
|
||||
}
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_path_compare_wc(const char *path, const char *wildcard, uint8_t ignore_case) {
|
||||
while (*path != 0) {
|
||||
switch (*wildcard) {
|
||||
case '*':
|
||||
|
||||
if (*(wildcard + 1) == 0)
|
||||
return MZ_OK;
|
||||
|
||||
while (*path != 0) {
|
||||
if (mz_path_compare_wc(path, (wildcard + 1), ignore_case) == MZ_OK)
|
||||
return MZ_OK;
|
||||
|
||||
path += 1;
|
||||
}
|
||||
|
||||
return MZ_EXIST_ERROR;
|
||||
|
||||
default:
|
||||
/* Ignore differences in path slashes on platforms */
|
||||
if ((*path == '\\' && *wildcard == '/') || (*path == '/' && *wildcard == '\\'))
|
||||
break;
|
||||
|
||||
if (ignore_case) {
|
||||
if (tolower(*path) != tolower(*wildcard))
|
||||
return MZ_EXIST_ERROR;
|
||||
} else {
|
||||
if (*path != *wildcard)
|
||||
return MZ_EXIST_ERROR;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
path += 1;
|
||||
wildcard += 1;
|
||||
}
|
||||
|
||||
if ((*wildcard != 0) && (*wildcard != '*'))
|
||||
return MZ_EXIST_ERROR;
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_path_resolve(const char *path, char *output, int32_t max_output) {
|
||||
const char *source = path;
|
||||
const char *check = output;
|
||||
char *target = output;
|
||||
|
||||
|
||||
if (max_output <= 0)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
while (*source != 0 && max_output > 1) {
|
||||
check = source;
|
||||
if ((*check == '\\') || (*check == '/'))
|
||||
check += 1;
|
||||
|
||||
if ((source == path) || (target == output) || (check != source)) {
|
||||
/* Skip double paths */
|
||||
if ((*check == '\\') || (*check == '/')) {
|
||||
source += 1;
|
||||
continue;
|
||||
}
|
||||
if (*check == '.') {
|
||||
check += 1;
|
||||
|
||||
/* Remove . if at end of string and not at the beginning */
|
||||
if ((*check == 0) && (source != path && target != output)) {
|
||||
/* Copy last slash */
|
||||
*target = *source;
|
||||
target += 1;
|
||||
max_output -= 1;
|
||||
source += (check - source);
|
||||
continue;
|
||||
}
|
||||
/* Remove . if not at end of string */
|
||||
else if ((*check == '\\') || (*check == '/')) {
|
||||
source += (check - source);
|
||||
/* Skip slash if at beginning of string */
|
||||
if (target == output && *source != 0)
|
||||
source += 1;
|
||||
continue;
|
||||
}
|
||||
/* Go to parent directory .. */
|
||||
else if (*check == '.') {
|
||||
check += 1;
|
||||
if ((*check == 0) || (*check == '\\' || *check == '/')) {
|
||||
source += (check - source);
|
||||
|
||||
/* Search backwards for previous slash */
|
||||
if (target != output) {
|
||||
target -= 1;
|
||||
do {
|
||||
if ((*target == '\\') || (*target == '/'))
|
||||
break;
|
||||
|
||||
target -= 1;
|
||||
max_output += 1;
|
||||
} while (target > output);
|
||||
}
|
||||
|
||||
if ((target == output) && (*source != 0))
|
||||
source += 1;
|
||||
if ((*target == '\\' || *target == '/') && (*source == 0))
|
||||
target += 1;
|
||||
|
||||
*target = 0;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
*target = *source;
|
||||
|
||||
source += 1;
|
||||
target += 1;
|
||||
max_output -= 1;
|
||||
}
|
||||
|
||||
*target = 0;
|
||||
|
||||
if (*path == 0)
|
||||
return MZ_INTERNAL_ERROR;
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_path_remove_filename(char *path) {
|
||||
char *path_ptr = NULL;
|
||||
|
||||
if (path == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
path_ptr = path + strlen(path) - 1;
|
||||
|
||||
while (path_ptr > path) {
|
||||
if ((*path_ptr == '/') || (*path_ptr == '\\')) {
|
||||
*path_ptr = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
path_ptr -= 1;
|
||||
}
|
||||
|
||||
if (path_ptr == path)
|
||||
*path_ptr = 0;
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_path_remove_extension(char *path) {
|
||||
char *path_ptr = NULL;
|
||||
|
||||
if (path == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
path_ptr = path + strlen(path) - 1;
|
||||
|
||||
while (path_ptr > path) {
|
||||
if ((*path_ptr == '/') || (*path_ptr == '\\'))
|
||||
break;
|
||||
if (*path_ptr == '.') {
|
||||
*path_ptr = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
path_ptr -= 1;
|
||||
}
|
||||
|
||||
if (path_ptr == path)
|
||||
*path_ptr = 0;
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_path_get_filename(const char *path, const char **filename) {
|
||||
const char *match = NULL;
|
||||
|
||||
if (path == NULL || filename == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
*filename = NULL;
|
||||
|
||||
for (match = path; *match != 0; match += 1) {
|
||||
if ((*match == '\\') || (*match == '/'))
|
||||
*filename = match + 1;
|
||||
}
|
||||
|
||||
if (*filename == NULL)
|
||||
return MZ_EXIST_ERROR;
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_dir_make(const char *path) {
|
||||
int32_t err = MZ_OK;
|
||||
int16_t len = 0;
|
||||
char *current_dir = NULL;
|
||||
char *match = NULL;
|
||||
char hold = 0;
|
||||
|
||||
|
||||
len = (int16_t)strlen(path);
|
||||
if (len <= 0)
|
||||
return 0;
|
||||
|
||||
current_dir = (char *)MZ_ALLOC((uint16_t)len + 1);
|
||||
if (current_dir == NULL)
|
||||
return MZ_MEM_ERROR;
|
||||
|
||||
strcpy(current_dir, path);
|
||||
mz_path_remove_slash(current_dir);
|
||||
|
||||
err = mz_os_make_dir(current_dir);
|
||||
if (err != MZ_OK) {
|
||||
match = current_dir + 1;
|
||||
while (1) {
|
||||
while (*match != 0 && *match != '\\' && *match != '/')
|
||||
match += 1;
|
||||
hold = *match;
|
||||
*match = 0;
|
||||
|
||||
err = mz_os_make_dir(current_dir);
|
||||
if (err != MZ_OK)
|
||||
break;
|
||||
if (hold == 0)
|
||||
break;
|
||||
|
||||
*match = hold;
|
||||
match += 1;
|
||||
}
|
||||
}
|
||||
|
||||
MZ_FREE(current_dir);
|
||||
return err;
|
||||
}
|
||||
|
||||
int32_t mz_file_get_crc(const char *path, uint32_t *result_crc) {
|
||||
void *stream = NULL;
|
||||
uint32_t crc32 = 0;
|
||||
int32_t read = 0;
|
||||
int32_t err = MZ_OK;
|
||||
uint8_t buf[16384];
|
||||
|
||||
mz_stream_os_create(&stream);
|
||||
|
||||
err = mz_stream_os_open(stream, path, MZ_OPEN_MODE_READ);
|
||||
|
||||
if (err == MZ_OK) {
|
||||
do {
|
||||
read = mz_stream_os_read(stream, buf, sizeof(buf));
|
||||
|
||||
if (read < 0) {
|
||||
err = read;
|
||||
break;
|
||||
}
|
||||
|
||||
crc32 = mz_crypt_crc32_update(crc32, buf, read);
|
||||
} while ((err == MZ_OK) && (read > 0));
|
||||
|
||||
mz_stream_os_close(stream);
|
||||
}
|
||||
|
||||
*result_crc = crc32;
|
||||
|
||||
mz_stream_os_delete(&stream);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
|
|
@ -0,0 +1,175 @@
|
|||
/* mz_os.h -- System functions
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
#ifndef MZ_OS_H
|
||||
#define MZ_OS_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#if defined(__APPLE__)
|
||||
# define MZ_VERSION_MADEBY_HOST_SYSTEM (MZ_HOST_SYSTEM_OSX_DARWIN)
|
||||
#elif defined(__riscos__)
|
||||
# define MZ_VERSION_MADEBY_HOST_SYSTEM (MZ_HOST_SYSTEM_RISCOS)
|
||||
#elif defined(_WIN32)
|
||||
# define MZ_VERSION_MADEBY_HOST_SYSTEM (MZ_HOST_SYSTEM_WINDOWS_NTFS)
|
||||
#else
|
||||
# define MZ_VERSION_MADEBY_HOST_SYSTEM (MZ_HOST_SYSTEM_UNIX)
|
||||
#endif
|
||||
|
||||
#if defined(HAVE_LZMA) || defined(HAVE_LIBCOMP)
|
||||
# define MZ_VERSION_MADEBY_ZIP_VERSION (63)
|
||||
#elif defined(HAVE_WZAES)
|
||||
# define MZ_VERSION_MADEBY_ZIP_VERSION (51)
|
||||
#elif defined(HAVE_BZIP2)
|
||||
# define MZ_VERSION_MADEBY_ZIP_VERSION (46)
|
||||
#else
|
||||
# define MZ_VERSION_MADEBY_ZIP_VERSION (45)
|
||||
#endif
|
||||
|
||||
#define MZ_VERSION_MADEBY ((MZ_VERSION_MADEBY_HOST_SYSTEM << 8) | \
|
||||
(MZ_VERSION_MADEBY_ZIP_VERSION))
|
||||
|
||||
#define MZ_PATH_SLASH_UNIX ('/')
|
||||
#if defined(_WIN32)
|
||||
# define MZ_PATH_SLASH_PLATFORM ('\\')
|
||||
#else
|
||||
# define MZ_PATH_SLASH_PLATFORM (MZ_PATH_SLASH_UNIX)
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#if defined(_WIN32)
|
||||
struct dirent {
|
||||
char d_name[256];
|
||||
};
|
||||
typedef void* DIR;
|
||||
#else
|
||||
#include <dirent.h>
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
/* Shared functions */
|
||||
|
||||
int32_t mz_path_combine(char *path, const char *join, int32_t max_path);
|
||||
/* Combines two paths */
|
||||
|
||||
int32_t mz_path_append_slash(char *path, int32_t max_path, char slash);
|
||||
/* Appends a path slash on to the end of the path */
|
||||
|
||||
int32_t mz_path_remove_slash(char *path);
|
||||
/* Removes a path slash from the end of the path */
|
||||
|
||||
int32_t mz_path_has_slash(const char *path);
|
||||
/* Returns whether or not the path ends with slash */
|
||||
|
||||
int32_t mz_path_convert_slashes(char *path, char slash);
|
||||
/* Converts the slashes in a path */
|
||||
|
||||
int32_t mz_path_compare_wc(const char *path, const char *wildcard, uint8_t ignore_case);
|
||||
/* Compare two paths with wildcard */
|
||||
|
||||
int32_t mz_path_resolve(const char *path, char *target, int32_t max_target);
|
||||
/* Resolves path */
|
||||
|
||||
int32_t mz_path_remove_filename(char *path);
|
||||
/* Remove the filename from a path */
|
||||
|
||||
int32_t mz_path_remove_extension(char *path);
|
||||
/* Remove the extension from a path */
|
||||
|
||||
int32_t mz_path_get_filename(const char *path, const char **filename);
|
||||
/* Get the filename from a path */
|
||||
|
||||
int32_t mz_dir_make(const char *path);
|
||||
/* Creates a directory recursively */
|
||||
|
||||
int32_t mz_file_get_crc(const char *path, uint32_t *result_crc);
|
||||
/* Gets the crc32 hash of a file */
|
||||
|
||||
/***************************************************************************/
|
||||
/* Platform specific functions */
|
||||
|
||||
wchar_t *mz_os_unicode_string_create(const char *string, int32_t encoding);
|
||||
/* Create unicode string from a utf8 string */
|
||||
|
||||
void mz_os_unicode_string_delete(wchar_t **string);
|
||||
/* Delete a unicode string that was created */
|
||||
|
||||
uint8_t *mz_os_utf8_string_create(const char *string, int32_t encoding);
|
||||
/* Create a utf8 string from a string with another encoding */
|
||||
|
||||
void mz_os_utf8_string_delete(uint8_t **string);
|
||||
/* Delete a utf8 string that was created */
|
||||
|
||||
int32_t mz_os_rand(uint8_t *buf, int32_t size);
|
||||
/* Random number generator (not cryptographically secure) */
|
||||
|
||||
int32_t mz_os_rename(const char *source_path, const char *target_path);
|
||||
/* Rename a file */
|
||||
|
||||
int32_t mz_os_unlink(const char *path);
|
||||
/* Delete an existing file */
|
||||
|
||||
int32_t mz_os_file_exists(const char *path);
|
||||
/* Check to see if a file exists */
|
||||
|
||||
int64_t mz_os_get_file_size(const char *path);
|
||||
/* Gets the length of a file */
|
||||
|
||||
int32_t mz_os_get_file_date(const char *path, time_t *modified_date, time_t *accessed_date, time_t *creation_date);
|
||||
/* Gets a file's modified, access, and creation dates if supported */
|
||||
|
||||
int32_t mz_os_set_file_date(const char *path, time_t modified_date, time_t accessed_date, time_t creation_date);
|
||||
/* Sets a file's modified, access, and creation dates if supported */
|
||||
|
||||
int32_t mz_os_get_file_attribs(const char *path, uint32_t *attributes);
|
||||
/* Gets a file's attributes */
|
||||
|
||||
int32_t mz_os_set_file_attribs(const char *path, uint32_t attributes);
|
||||
/* Sets a file's attributes */
|
||||
|
||||
int32_t mz_os_make_dir(const char *path);
|
||||
/* Recursively creates a directory */
|
||||
|
||||
DIR* mz_os_open_dir(const char *path);
|
||||
/* Opens a directory for listing */
|
||||
struct
|
||||
dirent* mz_os_read_dir(DIR *dir);
|
||||
/* Reads a directory listing entry */
|
||||
|
||||
int32_t mz_os_close_dir(DIR *dir);
|
||||
/* Closes a directory that has been opened for listing */
|
||||
|
||||
int32_t mz_os_is_dir(const char *path);
|
||||
/* Checks to see if path is a directory */
|
||||
|
||||
int32_t mz_os_is_symlink(const char *path);
|
||||
/* Checks to see if path is a symbolic link */
|
||||
|
||||
int32_t mz_os_make_symlink(const char *path, const char *target_path);
|
||||
/* Creates a symbolic link pointing to a target */
|
||||
|
||||
int32_t mz_os_read_symlink(const char *path, char *target_path, int32_t max_target_path);
|
||||
/* Gets the target path for a symbolic link */
|
||||
|
||||
uint64_t mz_os_ms_time(void);
|
||||
/* Gets the time in milliseconds */
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,367 @@
|
|||
/* mz_os_posix.c -- System functions for posix
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
#include "mz.h"
|
||||
#include "mz_strm.h"
|
||||
#include "mz_os.h"
|
||||
|
||||
#include <stdio.h> /* rename */
|
||||
#include <errno.h>
|
||||
#if defined(HAVE_ICONV)
|
||||
#include <iconv.h>
|
||||
#endif
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
#ifndef _WIN32
|
||||
# include <utime.h>
|
||||
# include <unistd.h>
|
||||
#endif
|
||||
#if defined(__APPLE__)
|
||||
# include <mach/clock.h>
|
||||
# include <mach/mach.h>
|
||||
#endif
|
||||
|
||||
#if defined(HAVE_GETRANDOM)
|
||||
# include <sys/random.h>
|
||||
#endif
|
||||
#if defined(HAVE_LIBBSD)
|
||||
# include <sys/types.h>
|
||||
# ifndef __u_char_defined
|
||||
typedef unsigned char u_char;
|
||||
# endif
|
||||
# include <bsd/stdlib.h> /* arc4random_buf */
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#if defined(HAVE_ICONV)
|
||||
uint8_t *mz_os_utf8_string_create(const char *string, int32_t encoding) {
|
||||
iconv_t cd;
|
||||
const char *from_encoding = NULL;
|
||||
size_t result = 0;
|
||||
size_t string_length = 0;
|
||||
size_t string_utf8_size = 0;
|
||||
uint8_t *string_utf8 = NULL;
|
||||
uint8_t *string_utf8_ptr = NULL;
|
||||
|
||||
if (string == NULL)
|
||||
return NULL;
|
||||
|
||||
if (encoding == MZ_ENCODING_CODEPAGE_437)
|
||||
from_encoding = "CP437";
|
||||
else if (encoding == MZ_ENCODING_CODEPAGE_932)
|
||||
from_encoding = "CP932";
|
||||
else if (encoding == MZ_ENCODING_CODEPAGE_936)
|
||||
from_encoding = "CP936";
|
||||
else if (encoding == MZ_ENCODING_CODEPAGE_950)
|
||||
from_encoding = "CP950";
|
||||
else if (encoding == MZ_ENCODING_UTF8)
|
||||
from_encoding = "UTF-8";
|
||||
else
|
||||
return NULL;
|
||||
|
||||
cd = iconv_open("UTF-8", from_encoding);
|
||||
if (cd == (iconv_t)-1)
|
||||
return NULL;
|
||||
|
||||
string_length = strlen(string);
|
||||
string_utf8_size = string_length * 2;
|
||||
string_utf8 = (uint8_t *)MZ_ALLOC((int32_t)(string_utf8_size + 1));
|
||||
string_utf8_ptr = string_utf8;
|
||||
|
||||
if (string_utf8) {
|
||||
memset(string_utf8, 0, string_utf8_size + 1);
|
||||
|
||||
result = iconv(cd, (char **)&string, &string_length,
|
||||
(char **)&string_utf8_ptr, &string_utf8_size);
|
||||
}
|
||||
|
||||
iconv_close(cd);
|
||||
|
||||
if (result == (size_t)-1) {
|
||||
MZ_FREE(string_utf8);
|
||||
string_utf8 = NULL;
|
||||
}
|
||||
|
||||
return string_utf8;
|
||||
}
|
||||
#else
|
||||
uint8_t *mz_os_utf8_string_create(const char *string, int32_t encoding) {
|
||||
size_t string_length = 0;
|
||||
uint8_t *string_copy = NULL;
|
||||
|
||||
string_length = strlen(string);
|
||||
string_copy = (uint8_t *)MZ_ALLOC((int32_t)(string_length + 1));
|
||||
strncpy((char *)string_copy, string, string_length);
|
||||
string_copy[string_length] = 0;
|
||||
|
||||
return string_copy;
|
||||
}
|
||||
#endif
|
||||
|
||||
void mz_os_utf8_string_delete(uint8_t **string) {
|
||||
if (string != NULL) {
|
||||
MZ_FREE(*string);
|
||||
*string = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#if defined(HAVE_ARC4RANDOM_BUF)
|
||||
int32_t mz_os_rand(uint8_t *buf, int32_t size) {
|
||||
if (size < 0)
|
||||
return 0;
|
||||
arc4random_buf(buf, (uint32_t)size);
|
||||
return size;
|
||||
}
|
||||
#elif defined(HAVE_ARC4RANDOM)
|
||||
int32_t mz_os_rand(uint8_t *buf, int32_t size) {
|
||||
int32_t left = size;
|
||||
for (; left > 2; left -= 3, buf += 3) {
|
||||
uint32_t val = arc4random();
|
||||
|
||||
buf[0] = (val) & 0xFF;
|
||||
buf[1] = (val >> 8) & 0xFF;
|
||||
buf[2] = (val >> 16) & 0xFF;
|
||||
}
|
||||
for (; left > 0; left--, buf++) {
|
||||
*buf = arc4random() & 0xFF;
|
||||
}
|
||||
return size - left;
|
||||
}
|
||||
#elif defined(HAVE_GETRANDOM)
|
||||
int32_t mz_os_rand(uint8_t *buf, int32_t size) {
|
||||
int32_t left = size;
|
||||
int32_t written = 0;
|
||||
|
||||
while (left > 0) {
|
||||
written = getrandom(buf, left, 0);
|
||||
if (written < 0)
|
||||
return MZ_INTERNAL_ERROR;
|
||||
|
||||
buf += written;
|
||||
left -= written;
|
||||
}
|
||||
return size - left;
|
||||
}
|
||||
#else
|
||||
int32_t mz_os_rand(uint8_t *buf, int32_t size) {
|
||||
static unsigned calls = 0;
|
||||
int32_t i = 0;
|
||||
|
||||
/* Ensure different random header each time */
|
||||
if (++calls == 1) {
|
||||
#define PI_SEED 3141592654UL
|
||||
srand((unsigned)(time(NULL) ^ PI_SEED));
|
||||
}
|
||||
|
||||
while (i < size)
|
||||
buf[i++] = (rand() >> 7) & 0xff;
|
||||
|
||||
return size;
|
||||
}
|
||||
#endif
|
||||
|
||||
int32_t mz_os_rename(const char *source_path, const char *target_path) {
|
||||
if (rename(source_path, target_path) == -1)
|
||||
return MZ_EXIST_ERROR;
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_os_unlink(const char *path) {
|
||||
if (unlink(path) == -1)
|
||||
return MZ_EXIST_ERROR;
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_os_file_exists(const char *path) {
|
||||
struct stat path_stat;
|
||||
|
||||
memset(&path_stat, 0, sizeof(path_stat));
|
||||
if (stat(path, &path_stat) == 0)
|
||||
return MZ_OK;
|
||||
return MZ_EXIST_ERROR;
|
||||
}
|
||||
|
||||
int64_t mz_os_get_file_size(const char *path) {
|
||||
struct stat path_stat;
|
||||
|
||||
memset(&path_stat, 0, sizeof(path_stat));
|
||||
if (stat(path, &path_stat) == 0) {
|
||||
/* Stat returns size taken up by directory entry, so return 0 */
|
||||
if (S_ISDIR(path_stat.st_mode))
|
||||
return 0;
|
||||
|
||||
return path_stat.st_size;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int32_t mz_os_get_file_date(const char *path, time_t *modified_date, time_t *accessed_date, time_t *creation_date) {
|
||||
struct stat path_stat;
|
||||
char *name = NULL;
|
||||
size_t len = 0;
|
||||
int32_t err = MZ_INTERNAL_ERROR;
|
||||
|
||||
memset(&path_stat, 0, sizeof(path_stat));
|
||||
|
||||
if (strcmp(path, "-") != 0) {
|
||||
/* Not all systems allow stat'ing a file with / appended */
|
||||
len = strlen(path);
|
||||
name = (char *)malloc(len + 1);
|
||||
strncpy(name, path, len + 1);
|
||||
mz_path_remove_slash(name);
|
||||
|
||||
if (stat(name, &path_stat) == 0) {
|
||||
if (modified_date != NULL)
|
||||
*modified_date = path_stat.st_mtime;
|
||||
if (accessed_date != NULL)
|
||||
*accessed_date = path_stat.st_atime;
|
||||
/* Creation date not supported */
|
||||
if (creation_date != NULL)
|
||||
*creation_date = 0;
|
||||
|
||||
err = MZ_OK;
|
||||
}
|
||||
|
||||
free(name);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
int32_t mz_os_set_file_date(const char *path, time_t modified_date, time_t accessed_date, time_t creation_date) {
|
||||
struct utimbuf ut;
|
||||
|
||||
ut.actime = accessed_date;
|
||||
ut.modtime = modified_date;
|
||||
|
||||
/* Creation date not supported */
|
||||
MZ_UNUSED(creation_date);
|
||||
|
||||
if (utime(path, &ut) != 0)
|
||||
return MZ_INTERNAL_ERROR;
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_os_get_file_attribs(const char *path, uint32_t *attributes) {
|
||||
struct stat path_stat;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
memset(&path_stat, 0, sizeof(path_stat));
|
||||
if (lstat(path, &path_stat) == -1)
|
||||
err = MZ_INTERNAL_ERROR;
|
||||
*attributes = path_stat.st_mode;
|
||||
return err;
|
||||
}
|
||||
|
||||
int32_t mz_os_set_file_attribs(const char *path, uint32_t attributes) {
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
if (chmod(path, (mode_t)attributes) == -1)
|
||||
err = MZ_INTERNAL_ERROR;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
int32_t mz_os_make_dir(const char *path) {
|
||||
int32_t err = 0;
|
||||
|
||||
err = mkdir(path, 0755);
|
||||
|
||||
if (err != 0 && errno != EEXIST)
|
||||
return MZ_INTERNAL_ERROR;
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
DIR* mz_os_open_dir(const char *path) {
|
||||
return opendir(path);
|
||||
}
|
||||
|
||||
struct dirent* mz_os_read_dir(DIR *dir) {
|
||||
if (dir == NULL)
|
||||
return NULL;
|
||||
return readdir(dir);
|
||||
}
|
||||
|
||||
int32_t mz_os_close_dir(DIR *dir) {
|
||||
if (dir == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
if (closedir(dir) == -1)
|
||||
return MZ_INTERNAL_ERROR;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_os_is_dir(const char *path) {
|
||||
struct stat path_stat;
|
||||
|
||||
memset(&path_stat, 0, sizeof(path_stat));
|
||||
stat(path, &path_stat);
|
||||
if (S_ISDIR(path_stat.st_mode))
|
||||
return MZ_OK;
|
||||
|
||||
return MZ_EXIST_ERROR;
|
||||
}
|
||||
|
||||
int32_t mz_os_is_symlink(const char *path) {
|
||||
struct stat path_stat;
|
||||
|
||||
memset(&path_stat, 0, sizeof(path_stat));
|
||||
lstat(path, &path_stat);
|
||||
if (S_ISLNK(path_stat.st_mode))
|
||||
return MZ_OK;
|
||||
|
||||
return MZ_EXIST_ERROR;
|
||||
}
|
||||
|
||||
int32_t mz_os_make_symlink(const char *path, const char *target_path) {
|
||||
if (symlink(target_path, path) != 0)
|
||||
return MZ_INTERNAL_ERROR;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_os_read_symlink(const char *path, char *target_path, int32_t max_target_path) {
|
||||
size_t length = 0;
|
||||
|
||||
length = (size_t)readlink(path, target_path, max_target_path - 1);
|
||||
if (length == (size_t)-1)
|
||||
return MZ_EXIST_ERROR;
|
||||
|
||||
target_path[length] = 0;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
uint64_t mz_os_ms_time(void) {
|
||||
struct timespec ts;
|
||||
|
||||
#if defined(__APPLE__)
|
||||
clock_serv_t cclock;
|
||||
mach_timespec_t mts;
|
||||
|
||||
host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
|
||||
clock_get_time(cclock, &mts);
|
||||
mach_port_deallocate(mach_task_self(), cclock);
|
||||
|
||||
ts.tv_sec = mts.tv_sec;
|
||||
ts.tv_nsec = mts.tv_nsec;
|
||||
#else
|
||||
clock_gettime(CLOCK_MONOTONIC, &ts);
|
||||
#endif
|
||||
|
||||
return ((uint64_t)ts.tv_sec * 1000) + ((uint64_t)ts.tv_nsec / 1000000);
|
||||
}
|
||||
|
|
@ -0,0 +1,560 @@
|
|||
/* mz_strm.c -- Stream interface
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
#include "mz.h"
|
||||
#include "mz_strm.h"
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#define MZ_STREAM_FIND_SIZE (1024)
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_stream_open(void *stream, const char *path, int32_t mode) {
|
||||
mz_stream *strm = (mz_stream *)stream;
|
||||
if (strm == NULL || strm->vtbl == NULL || strm->vtbl->open == NULL)
|
||||
return MZ_STREAM_ERROR;
|
||||
return strm->vtbl->open(strm, path, mode);
|
||||
}
|
||||
|
||||
int32_t mz_stream_is_open(void *stream) {
|
||||
mz_stream *strm = (mz_stream *)stream;
|
||||
if (strm == NULL || strm->vtbl == NULL || strm->vtbl->is_open == NULL)
|
||||
return MZ_STREAM_ERROR;
|
||||
return strm->vtbl->is_open(strm);
|
||||
}
|
||||
|
||||
int32_t mz_stream_read(void *stream, void *buf, int32_t size) {
|
||||
mz_stream *strm = (mz_stream *)stream;
|
||||
if (strm == NULL || strm->vtbl == NULL || strm->vtbl->read == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
if (mz_stream_is_open(stream) != MZ_OK)
|
||||
return MZ_STREAM_ERROR;
|
||||
return strm->vtbl->read(strm, buf, size);
|
||||
}
|
||||
|
||||
static int32_t mz_stream_read_value(void *stream, uint64_t *value, int32_t len) {
|
||||
uint8_t buf[8];
|
||||
int32_t n = 0;
|
||||
int32_t i = 0;
|
||||
|
||||
*value = 0;
|
||||
if (mz_stream_read(stream, buf, len) == len) {
|
||||
for (n = 0; n < len; n += 1, i += 8)
|
||||
*value += ((uint64_t)buf[n]) << i;
|
||||
} else if (mz_stream_error(stream))
|
||||
return MZ_STREAM_ERROR;
|
||||
else
|
||||
return MZ_END_OF_STREAM;
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_read_uint8(void *stream, uint8_t *value) {
|
||||
int32_t err = MZ_OK;
|
||||
uint64_t value64 = 0;
|
||||
|
||||
*value = 0;
|
||||
err = mz_stream_read_value(stream, &value64, sizeof(uint8_t));
|
||||
if (err == MZ_OK)
|
||||
*value = (uint8_t)value64;
|
||||
return err;
|
||||
}
|
||||
|
||||
int32_t mz_stream_read_uint16(void *stream, uint16_t *value) {
|
||||
int32_t err = MZ_OK;
|
||||
uint64_t value64 = 0;
|
||||
|
||||
*value = 0;
|
||||
err = mz_stream_read_value(stream, &value64, sizeof(uint16_t));
|
||||
if (err == MZ_OK)
|
||||
*value = (uint16_t)value64;
|
||||
return err;
|
||||
}
|
||||
|
||||
int32_t mz_stream_read_uint32(void *stream, uint32_t *value) {
|
||||
int32_t err = MZ_OK;
|
||||
uint64_t value64 = 0;
|
||||
|
||||
*value = 0;
|
||||
err = mz_stream_read_value(stream, &value64, sizeof(uint32_t));
|
||||
if (err == MZ_OK)
|
||||
*value = (uint32_t)value64;
|
||||
return err;
|
||||
}
|
||||
|
||||
int32_t mz_stream_read_int64(void *stream, int64_t *value) {
|
||||
return mz_stream_read_value(stream, (uint64_t *)value, sizeof(uint64_t));
|
||||
}
|
||||
|
||||
int32_t mz_stream_read_uint64(void *stream, uint64_t *value) {
|
||||
return mz_stream_read_value(stream, value, sizeof(uint64_t));
|
||||
}
|
||||
|
||||
int32_t mz_stream_write(void *stream, const void *buf, int32_t size) {
|
||||
mz_stream *strm = (mz_stream *)stream;
|
||||
if (size == 0)
|
||||
return size;
|
||||
if (strm == NULL || strm->vtbl == NULL || strm->vtbl->write == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
if (mz_stream_is_open(stream) != MZ_OK)
|
||||
return MZ_STREAM_ERROR;
|
||||
return strm->vtbl->write(strm, buf, size);
|
||||
}
|
||||
|
||||
static int32_t mz_stream_write_value(void *stream, uint64_t value, int32_t len) {
|
||||
uint8_t buf[8];
|
||||
int32_t n = 0;
|
||||
|
||||
for (n = 0; n < len; n += 1) {
|
||||
buf[n] = (uint8_t)(value & 0xff);
|
||||
value >>= 8;
|
||||
}
|
||||
|
||||
if (value != 0) {
|
||||
/* Data overflow - hack for ZIP64 (X Roche) */
|
||||
for (n = 0; n < len; n += 1)
|
||||
buf[n] = 0xff;
|
||||
}
|
||||
|
||||
if (mz_stream_write(stream, buf, len) != len)
|
||||
return MZ_STREAM_ERROR;
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_write_uint8(void *stream, uint8_t value) {
|
||||
return mz_stream_write_value(stream, value, sizeof(uint8_t));
|
||||
}
|
||||
|
||||
int32_t mz_stream_write_uint16(void *stream, uint16_t value) {
|
||||
return mz_stream_write_value(stream, value, sizeof(uint16_t));
|
||||
}
|
||||
|
||||
int32_t mz_stream_write_uint32(void *stream, uint32_t value) {
|
||||
return mz_stream_write_value(stream, value, sizeof(uint32_t));
|
||||
}
|
||||
|
||||
int32_t mz_stream_write_int64(void *stream, int64_t value) {
|
||||
return mz_stream_write_value(stream, (uint64_t)value, sizeof(uint64_t));
|
||||
}
|
||||
|
||||
int32_t mz_stream_write_uint64(void *stream, uint64_t value) {
|
||||
return mz_stream_write_value(stream, value, sizeof(uint64_t));
|
||||
}
|
||||
|
||||
int32_t mz_stream_copy(void *target, void *source, int32_t len) {
|
||||
return mz_stream_copy_stream(target, NULL, source, NULL, len);
|
||||
}
|
||||
|
||||
int32_t mz_stream_copy_to_end(void *target, void *source) {
|
||||
return mz_stream_copy_stream_to_end(target, NULL, source, NULL);
|
||||
}
|
||||
|
||||
int32_t mz_stream_copy_stream(void *target, mz_stream_write_cb write_cb, void *source,
|
||||
mz_stream_read_cb read_cb, int32_t len) {
|
||||
uint8_t buf[16384];
|
||||
int32_t bytes_to_copy = 0;
|
||||
int32_t read = 0;
|
||||
int32_t written = 0;
|
||||
|
||||
if (write_cb == NULL)
|
||||
write_cb = mz_stream_write;
|
||||
if (read_cb == NULL)
|
||||
read_cb = mz_stream_read;
|
||||
|
||||
while (len > 0) {
|
||||
bytes_to_copy = len;
|
||||
if (bytes_to_copy > (int32_t)sizeof(buf))
|
||||
bytes_to_copy = sizeof(buf);
|
||||
read = read_cb(source, buf, bytes_to_copy);
|
||||
if (read <= 0)
|
||||
return MZ_STREAM_ERROR;
|
||||
written = write_cb(target, buf, read);
|
||||
if (written != read)
|
||||
return MZ_STREAM_ERROR;
|
||||
len -= read;
|
||||
}
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_copy_stream_to_end(void *target, mz_stream_write_cb write_cb, void *source,
|
||||
mz_stream_read_cb read_cb) {
|
||||
uint8_t buf[16384];
|
||||
int32_t read = 0;
|
||||
int32_t written = 0;
|
||||
|
||||
if (write_cb == NULL)
|
||||
write_cb = mz_stream_write;
|
||||
if (read_cb == NULL)
|
||||
read_cb = mz_stream_read;
|
||||
|
||||
read = read_cb(source, buf, sizeof(buf));
|
||||
while (read > 0) {
|
||||
written = write_cb(target, buf, read);
|
||||
if (written != read)
|
||||
return MZ_STREAM_ERROR;
|
||||
read = read_cb(source, buf, sizeof(buf));
|
||||
}
|
||||
|
||||
if (read < 0)
|
||||
return MZ_STREAM_ERROR;
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int64_t mz_stream_tell(void *stream) {
|
||||
mz_stream *strm = (mz_stream *)stream;
|
||||
if (strm == NULL || strm->vtbl == NULL || strm->vtbl->tell == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
if (mz_stream_is_open(stream) != MZ_OK)
|
||||
return MZ_STREAM_ERROR;
|
||||
return strm->vtbl->tell(strm);
|
||||
}
|
||||
|
||||
int32_t mz_stream_seek(void *stream, int64_t offset, int32_t origin) {
|
||||
mz_stream *strm = (mz_stream *)stream;
|
||||
if (strm == NULL || strm->vtbl == NULL || strm->vtbl->seek == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
if (mz_stream_is_open(stream) != MZ_OK)
|
||||
return MZ_STREAM_ERROR;
|
||||
if (origin == MZ_SEEK_SET && offset < 0)
|
||||
return MZ_SEEK_ERROR;
|
||||
return strm->vtbl->seek(strm, offset, origin);
|
||||
}
|
||||
|
||||
int32_t mz_stream_find(void *stream, const void *find, int32_t find_size, int64_t max_seek, int64_t *position) {
|
||||
uint8_t buf[MZ_STREAM_FIND_SIZE];
|
||||
int32_t buf_pos = 0;
|
||||
int32_t read_size = sizeof(buf);
|
||||
int32_t read = 0;
|
||||
int64_t read_pos = 0;
|
||||
int64_t start_pos = 0;
|
||||
int64_t disk_pos = 0;
|
||||
int32_t i = 0;
|
||||
uint8_t first = 1;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
if (stream == NULL || find == NULL || position == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
if (find_size < 0 || find_size >= (int32_t)sizeof(buf))
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
*position = -1;
|
||||
|
||||
start_pos = mz_stream_tell(stream);
|
||||
|
||||
while (read_pos < max_seek) {
|
||||
if (read_size > (int32_t)(max_seek - read_pos - buf_pos) && (max_seek - read_pos - buf_pos) < (int64_t)sizeof(buf))
|
||||
read_size = (int32_t)(max_seek - read_pos - buf_pos);
|
||||
|
||||
read = mz_stream_read(stream, buf + buf_pos, read_size);
|
||||
if ((read <= 0) || (read + buf_pos < find_size))
|
||||
break;
|
||||
|
||||
for (i = 0; i <= read + buf_pos - find_size; i += 1) {
|
||||
if (memcmp(&buf[i], find, find_size) != 0)
|
||||
continue;
|
||||
|
||||
disk_pos = mz_stream_tell(stream);
|
||||
|
||||
/* Seek to position on disk where the data was found */
|
||||
err = mz_stream_seek(stream, disk_pos - ((int64_t)read + buf_pos - i), MZ_SEEK_SET);
|
||||
if (err != MZ_OK)
|
||||
return MZ_EXIST_ERROR;
|
||||
|
||||
*position = start_pos + read_pos + i;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
if (first) {
|
||||
read -= find_size;
|
||||
read_size -= find_size;
|
||||
buf_pos = find_size;
|
||||
first = 0;
|
||||
}
|
||||
|
||||
memmove(buf, buf + read, find_size);
|
||||
read_pos += read;
|
||||
}
|
||||
|
||||
return MZ_EXIST_ERROR;
|
||||
}
|
||||
|
||||
int32_t mz_stream_find_reverse(void *stream, const void *find, int32_t find_size, int64_t max_seek, int64_t *position) {
|
||||
uint8_t buf[MZ_STREAM_FIND_SIZE];
|
||||
int32_t buf_pos = 0;
|
||||
int32_t read_size = MZ_STREAM_FIND_SIZE;
|
||||
int64_t read_pos = 0;
|
||||
int32_t read = 0;
|
||||
int64_t start_pos = 0;
|
||||
int64_t disk_pos = 0;
|
||||
uint8_t first = 1;
|
||||
int32_t i = 0;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
if (stream == NULL || find == NULL || position == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
if (find_size < 0 || find_size >= (int32_t)sizeof(buf))
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
*position = -1;
|
||||
|
||||
start_pos = mz_stream_tell(stream);
|
||||
|
||||
while (read_pos < max_seek) {
|
||||
if (read_size > (int32_t)(max_seek - read_pos) && (max_seek - read_pos) < (int64_t)sizeof(buf))
|
||||
read_size = (int32_t)(max_seek - read_pos);
|
||||
|
||||
if (mz_stream_seek(stream, start_pos - (read_pos + read_size), MZ_SEEK_SET) != MZ_OK)
|
||||
break;
|
||||
read = mz_stream_read(stream, buf, read_size);
|
||||
if ((read <= 0) || (read + buf_pos < find_size))
|
||||
break;
|
||||
if (read + buf_pos < MZ_STREAM_FIND_SIZE)
|
||||
memmove(buf + MZ_STREAM_FIND_SIZE - (read + buf_pos), buf, read);
|
||||
|
||||
for (i = find_size; i <= (read + buf_pos); i += 1) {
|
||||
if (memcmp(&buf[MZ_STREAM_FIND_SIZE - i], find, find_size) != 0)
|
||||
continue;
|
||||
|
||||
disk_pos = mz_stream_tell(stream);
|
||||
|
||||
/* Seek to position on disk where the data was found */
|
||||
err = mz_stream_seek(stream, disk_pos + buf_pos - i, MZ_SEEK_SET);
|
||||
if (err != MZ_OK)
|
||||
return MZ_EXIST_ERROR;
|
||||
|
||||
*position = start_pos - (read_pos - buf_pos + i);
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
if (first) {
|
||||
read -= find_size;
|
||||
read_size -= find_size;
|
||||
buf_pos = find_size;
|
||||
first = 0;
|
||||
}
|
||||
|
||||
if (read == 0)
|
||||
break;
|
||||
|
||||
memmove(buf + read_size, buf, find_size);
|
||||
read_pos += read;
|
||||
}
|
||||
|
||||
return MZ_EXIST_ERROR;
|
||||
}
|
||||
|
||||
int32_t mz_stream_close(void *stream) {
|
||||
mz_stream *strm = (mz_stream *)stream;
|
||||
if (strm == NULL || strm->vtbl == NULL || strm->vtbl->close == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
if (mz_stream_is_open(stream) != MZ_OK)
|
||||
return MZ_STREAM_ERROR;
|
||||
return strm->vtbl->close(strm);
|
||||
}
|
||||
|
||||
int32_t mz_stream_error(void *stream) {
|
||||
mz_stream *strm = (mz_stream *)stream;
|
||||
if (strm == NULL || strm->vtbl == NULL || strm->vtbl->error == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
return strm->vtbl->error(strm);
|
||||
}
|
||||
|
||||
int32_t mz_stream_set_base(void *stream, void *base) {
|
||||
mz_stream *strm = (mz_stream *)stream;
|
||||
strm->base = (mz_stream *)base;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
void* mz_stream_get_interface(void *stream) {
|
||||
mz_stream *strm = (mz_stream *)stream;
|
||||
if (strm == NULL || strm->vtbl == NULL)
|
||||
return NULL;
|
||||
return (void *)strm->vtbl;
|
||||
}
|
||||
|
||||
int32_t mz_stream_get_prop_int64(void *stream, int32_t prop, int64_t *value) {
|
||||
mz_stream *strm = (mz_stream *)stream;
|
||||
if (strm == NULL || strm->vtbl == NULL || strm->vtbl->get_prop_int64 == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
return strm->vtbl->get_prop_int64(stream, prop, value);
|
||||
}
|
||||
|
||||
int32_t mz_stream_set_prop_int64(void *stream, int32_t prop, int64_t value) {
|
||||
mz_stream *strm = (mz_stream *)stream;
|
||||
if (strm == NULL || strm->vtbl == NULL || strm->vtbl->set_prop_int64 == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
return strm->vtbl->set_prop_int64(stream, prop, value);
|
||||
}
|
||||
|
||||
void *mz_stream_create(void **stream, mz_stream_vtbl *vtbl) {
|
||||
if (stream == NULL)
|
||||
return NULL;
|
||||
if (vtbl == NULL || vtbl->create == NULL)
|
||||
return NULL;
|
||||
return vtbl->create(stream);
|
||||
}
|
||||
|
||||
void mz_stream_delete(void **stream) {
|
||||
mz_stream *strm = NULL;
|
||||
if (stream == NULL)
|
||||
return;
|
||||
strm = (mz_stream *)*stream;
|
||||
if (strm != NULL && strm->vtbl != NULL && strm->vtbl->destroy != NULL)
|
||||
strm->vtbl->destroy(stream);
|
||||
*stream = NULL;
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
typedef struct mz_stream_raw_s {
|
||||
mz_stream stream;
|
||||
int64_t total_in;
|
||||
int64_t total_out;
|
||||
int64_t max_total_in;
|
||||
} mz_stream_raw;
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_stream_raw_open(void *stream, const char *path, int32_t mode) {
|
||||
MZ_UNUSED(stream);
|
||||
MZ_UNUSED(path);
|
||||
MZ_UNUSED(mode);
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_raw_is_open(void *stream) {
|
||||
mz_stream_raw *raw = (mz_stream_raw *)stream;
|
||||
return mz_stream_is_open(raw->stream.base);
|
||||
}
|
||||
|
||||
int32_t mz_stream_raw_read(void *stream, void *buf, int32_t size) {
|
||||
mz_stream_raw *raw = (mz_stream_raw *)stream;
|
||||
int32_t bytes_to_read = size;
|
||||
int32_t read = 0;
|
||||
|
||||
if (raw->max_total_in > 0) {
|
||||
if ((int64_t)bytes_to_read > (raw->max_total_in - raw->total_in))
|
||||
bytes_to_read = (int32_t)(raw->max_total_in - raw->total_in);
|
||||
}
|
||||
|
||||
read = mz_stream_read(raw->stream.base, buf, bytes_to_read);
|
||||
|
||||
if (read > 0) {
|
||||
raw->total_in += read;
|
||||
raw->total_out += read;
|
||||
}
|
||||
|
||||
return read;
|
||||
}
|
||||
|
||||
int32_t mz_stream_raw_write(void *stream, const void *buf, int32_t size) {
|
||||
mz_stream_raw *raw = (mz_stream_raw *)stream;
|
||||
int32_t written = 0;
|
||||
|
||||
written = mz_stream_write(raw->stream.base, buf, size);
|
||||
|
||||
if (written > 0) {
|
||||
raw->total_out += written;
|
||||
raw->total_in += written;
|
||||
}
|
||||
|
||||
return written;
|
||||
}
|
||||
|
||||
int64_t mz_stream_raw_tell(void *stream) {
|
||||
mz_stream_raw *raw = (mz_stream_raw *)stream;
|
||||
return mz_stream_tell(raw->stream.base);
|
||||
}
|
||||
|
||||
int32_t mz_stream_raw_seek(void *stream, int64_t offset, int32_t origin) {
|
||||
mz_stream_raw *raw = (mz_stream_raw *)stream;
|
||||
return mz_stream_seek(raw->stream.base, offset, origin);
|
||||
}
|
||||
|
||||
int32_t mz_stream_raw_close(void *stream) {
|
||||
MZ_UNUSED(stream);
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_raw_error(void *stream) {
|
||||
mz_stream_raw *raw = (mz_stream_raw *)stream;
|
||||
return mz_stream_error(raw->stream.base);
|
||||
}
|
||||
|
||||
int32_t mz_stream_raw_get_prop_int64(void *stream, int32_t prop, int64_t *value) {
|
||||
mz_stream_raw *raw = (mz_stream_raw *)stream;
|
||||
switch (prop) {
|
||||
case MZ_STREAM_PROP_TOTAL_IN:
|
||||
*value = raw->total_in;
|
||||
return MZ_OK;
|
||||
case MZ_STREAM_PROP_TOTAL_OUT:
|
||||
*value = raw->total_out;
|
||||
return MZ_OK;
|
||||
}
|
||||
return MZ_EXIST_ERROR;
|
||||
}
|
||||
|
||||
int32_t mz_stream_raw_set_prop_int64(void *stream, int32_t prop, int64_t value) {
|
||||
mz_stream_raw *raw = (mz_stream_raw *)stream;
|
||||
switch (prop) {
|
||||
case MZ_STREAM_PROP_TOTAL_IN_MAX:
|
||||
raw->max_total_in = value;
|
||||
return MZ_OK;
|
||||
}
|
||||
return MZ_EXIST_ERROR;
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
static mz_stream_vtbl mz_stream_raw_vtbl = {
|
||||
mz_stream_raw_open,
|
||||
mz_stream_raw_is_open,
|
||||
mz_stream_raw_read,
|
||||
mz_stream_raw_write,
|
||||
mz_stream_raw_tell,
|
||||
mz_stream_raw_seek,
|
||||
mz_stream_raw_close,
|
||||
mz_stream_raw_error,
|
||||
mz_stream_raw_create,
|
||||
mz_stream_raw_delete,
|
||||
mz_stream_raw_get_prop_int64,
|
||||
mz_stream_raw_set_prop_int64
|
||||
};
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
void *mz_stream_raw_create(void **stream) {
|
||||
mz_stream_raw *raw = NULL;
|
||||
|
||||
raw = (mz_stream_raw *)MZ_ALLOC(sizeof(mz_stream_raw));
|
||||
if (raw != NULL) {
|
||||
memset(raw, 0, sizeof(mz_stream_raw));
|
||||
raw->stream.vtbl = &mz_stream_raw_vtbl;
|
||||
}
|
||||
if (stream != NULL)
|
||||
*stream = raw;
|
||||
|
||||
return raw;
|
||||
}
|
||||
|
||||
void mz_stream_raw_delete(void **stream) {
|
||||
mz_stream_raw *raw = NULL;
|
||||
if (stream == NULL)
|
||||
return;
|
||||
raw = (mz_stream_raw *)*stream;
|
||||
if (raw != NULL)
|
||||
MZ_FREE(raw);
|
||||
*stream = NULL;
|
||||
}
|
||||
|
|
@ -0,0 +1,132 @@
|
|||
/* mz_strm.h -- Stream interface
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
#ifndef MZ_STREAM_H
|
||||
#define MZ_STREAM_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#define MZ_STREAM_PROP_TOTAL_IN (1)
|
||||
#define MZ_STREAM_PROP_TOTAL_IN_MAX (2)
|
||||
#define MZ_STREAM_PROP_TOTAL_OUT (3)
|
||||
#define MZ_STREAM_PROP_TOTAL_OUT_MAX (4)
|
||||
#define MZ_STREAM_PROP_HEADER_SIZE (5)
|
||||
#define MZ_STREAM_PROP_FOOTER_SIZE (6)
|
||||
#define MZ_STREAM_PROP_DISK_SIZE (7)
|
||||
#define MZ_STREAM_PROP_DISK_NUMBER (8)
|
||||
#define MZ_STREAM_PROP_COMPRESS_LEVEL (9)
|
||||
#define MZ_STREAM_PROP_COMPRESS_METHOD (10)
|
||||
#define MZ_STREAM_PROP_COMPRESS_WINDOW (11)
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
typedef int32_t (*mz_stream_open_cb) (void *stream, const char *path, int32_t mode);
|
||||
typedef int32_t (*mz_stream_is_open_cb) (void *stream);
|
||||
typedef int32_t (*mz_stream_read_cb) (void *stream, void *buf, int32_t size);
|
||||
typedef int32_t (*mz_stream_write_cb) (void *stream, const void *buf, int32_t size);
|
||||
typedef int64_t (*mz_stream_tell_cb) (void *stream);
|
||||
typedef int32_t (*mz_stream_seek_cb) (void *stream, int64_t offset, int32_t origin);
|
||||
typedef int32_t (*mz_stream_close_cb) (void *stream);
|
||||
typedef int32_t (*mz_stream_error_cb) (void *stream);
|
||||
typedef void* (*mz_stream_create_cb) (void **stream);
|
||||
typedef void (*mz_stream_destroy_cb) (void **stream);
|
||||
|
||||
typedef int32_t (*mz_stream_get_prop_int64_cb) (void *stream, int32_t prop, int64_t *value);
|
||||
typedef int32_t (*mz_stream_set_prop_int64_cb) (void *stream, int32_t prop, int64_t value);
|
||||
|
||||
typedef int32_t (*mz_stream_find_cb) (void *stream, const void *find, int32_t find_size,
|
||||
int64_t max_seek, int64_t *position);
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
typedef struct mz_stream_vtbl_s {
|
||||
mz_stream_open_cb open;
|
||||
mz_stream_is_open_cb is_open;
|
||||
mz_stream_read_cb read;
|
||||
mz_stream_write_cb write;
|
||||
mz_stream_tell_cb tell;
|
||||
mz_stream_seek_cb seek;
|
||||
mz_stream_close_cb close;
|
||||
mz_stream_error_cb error;
|
||||
mz_stream_create_cb create;
|
||||
mz_stream_destroy_cb destroy;
|
||||
|
||||
mz_stream_get_prop_int64_cb get_prop_int64;
|
||||
mz_stream_set_prop_int64_cb set_prop_int64;
|
||||
} mz_stream_vtbl;
|
||||
|
||||
typedef struct mz_stream_s {
|
||||
mz_stream_vtbl *vtbl;
|
||||
struct mz_stream_s *base;
|
||||
} mz_stream;
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_stream_open(void *stream, const char *path, int32_t mode);
|
||||
int32_t mz_stream_is_open(void *stream);
|
||||
int32_t mz_stream_read(void *stream, void *buf, int32_t size);
|
||||
int32_t mz_stream_read_uint8(void *stream, uint8_t *value);
|
||||
int32_t mz_stream_read_uint16(void *stream, uint16_t *value);
|
||||
int32_t mz_stream_read_uint32(void *stream, uint32_t *value);
|
||||
int32_t mz_stream_read_int64(void *stream, int64_t *value);
|
||||
int32_t mz_stream_read_uint64(void *stream, uint64_t *value);
|
||||
int32_t mz_stream_write(void *stream, const void *buf, int32_t size);
|
||||
int32_t mz_stream_write_uint8(void *stream, uint8_t value);
|
||||
int32_t mz_stream_write_uint16(void *stream, uint16_t value);
|
||||
int32_t mz_stream_write_uint32(void *stream, uint32_t value);
|
||||
int32_t mz_stream_write_int64(void *stream, int64_t value);
|
||||
int32_t mz_stream_write_uint64(void *stream, uint64_t value);
|
||||
int32_t mz_stream_copy(void *target, void *source, int32_t len);
|
||||
int32_t mz_stream_copy_to_end(void *target, void *source);
|
||||
int32_t mz_stream_copy_stream(void *target, mz_stream_write_cb write_cb, void *source, mz_stream_read_cb read_cb, int32_t len);
|
||||
int32_t mz_stream_copy_stream_to_end(void *target, mz_stream_write_cb write_cb, void *source, mz_stream_read_cb read_cb);
|
||||
int64_t mz_stream_tell(void *stream);
|
||||
int32_t mz_stream_seek(void *stream, int64_t offset, int32_t origin);
|
||||
int32_t mz_stream_find(void *stream, const void *find, int32_t find_size, int64_t max_seek, int64_t *position);
|
||||
int32_t mz_stream_find_reverse(void *stream, const void *find, int32_t find_size, int64_t max_seek, int64_t *position);
|
||||
int32_t mz_stream_close(void *stream);
|
||||
int32_t mz_stream_error(void *stream);
|
||||
|
||||
int32_t mz_stream_set_base(void *stream, void *base);
|
||||
void* mz_stream_get_interface(void *stream);
|
||||
int32_t mz_stream_get_prop_int64(void *stream, int32_t prop, int64_t *value);
|
||||
int32_t mz_stream_set_prop_int64(void *stream, int32_t prop, int64_t value);
|
||||
|
||||
void* mz_stream_create(void **stream, mz_stream_vtbl *vtbl);
|
||||
void mz_stream_delete(void **stream);
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_stream_raw_open(void *stream, const char *filename, int32_t mode);
|
||||
int32_t mz_stream_raw_is_open(void *stream);
|
||||
int32_t mz_stream_raw_read(void *stream, void *buf, int32_t size);
|
||||
int32_t mz_stream_raw_write(void *stream, const void *buf, int32_t size);
|
||||
int64_t mz_stream_raw_tell(void *stream);
|
||||
int32_t mz_stream_raw_seek(void *stream, int64_t offset, int32_t origin);
|
||||
int32_t mz_stream_raw_close(void *stream);
|
||||
int32_t mz_stream_raw_error(void *stream);
|
||||
|
||||
int32_t mz_stream_raw_get_prop_int64(void *stream, int32_t prop, int64_t *value);
|
||||
int32_t mz_stream_raw_set_prop_int64(void *stream, int32_t prop, int64_t value);
|
||||
|
||||
void* mz_stream_raw_create(void **stream);
|
||||
void mz_stream_raw_delete(void **stream);
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,385 @@
|
|||
/* mz_strm_buf.c -- Stream for buffering reads/writes
|
||||
part of the minizip-ng project
|
||||
|
||||
This version of ioapi is designed to buffer IO.
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
#include "mz.h"
|
||||
#include "mz_strm.h"
|
||||
#include "mz_strm_buf.h"
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
static mz_stream_vtbl mz_stream_buffered_vtbl = {
|
||||
mz_stream_buffered_open,
|
||||
mz_stream_buffered_is_open,
|
||||
mz_stream_buffered_read,
|
||||
mz_stream_buffered_write,
|
||||
mz_stream_buffered_tell,
|
||||
mz_stream_buffered_seek,
|
||||
mz_stream_buffered_close,
|
||||
mz_stream_buffered_error,
|
||||
mz_stream_buffered_create,
|
||||
mz_stream_buffered_delete,
|
||||
NULL,
|
||||
NULL
|
||||
};
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
typedef struct mz_stream_buffered_s {
|
||||
mz_stream stream;
|
||||
int32_t error;
|
||||
char readbuf[INT16_MAX];
|
||||
int32_t readbuf_len;
|
||||
int32_t readbuf_pos;
|
||||
int32_t readbuf_hits;
|
||||
int32_t readbuf_misses;
|
||||
char writebuf[INT16_MAX];
|
||||
int32_t writebuf_len;
|
||||
int32_t writebuf_pos;
|
||||
int32_t writebuf_hits;
|
||||
int32_t writebuf_misses;
|
||||
int64_t position;
|
||||
} mz_stream_buffered;
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#if 0
|
||||
# define mz_stream_buffered_print printf
|
||||
#else
|
||||
# define mz_stream_buffered_print(fmt,...)
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
static int32_t mz_stream_buffered_reset(void *stream) {
|
||||
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
|
||||
|
||||
buffered->readbuf_len = 0;
|
||||
buffered->readbuf_pos = 0;
|
||||
buffered->writebuf_len = 0;
|
||||
buffered->writebuf_pos = 0;
|
||||
buffered->position = 0;
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_buffered_open(void *stream, const char *path, int32_t mode) {
|
||||
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
|
||||
mz_stream_buffered_print("Buffered - Open (mode %" PRId32 ")\n", mode);
|
||||
mz_stream_buffered_reset(buffered);
|
||||
return mz_stream_open(buffered->stream.base, path, mode);
|
||||
}
|
||||
|
||||
int32_t mz_stream_buffered_is_open(void *stream) {
|
||||
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
|
||||
return mz_stream_is_open(buffered->stream.base);
|
||||
}
|
||||
|
||||
static int32_t mz_stream_buffered_flush(void *stream, int32_t *written) {
|
||||
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
|
||||
int32_t total_bytes_written = 0;
|
||||
int32_t bytes_to_write = buffered->writebuf_len;
|
||||
int32_t bytes_left_to_write = buffered->writebuf_len;
|
||||
int32_t bytes_written = 0;
|
||||
|
||||
*written = 0;
|
||||
|
||||
while (bytes_left_to_write > 0) {
|
||||
bytes_written = mz_stream_write(buffered->stream.base,
|
||||
buffered->writebuf + (bytes_to_write - bytes_left_to_write), bytes_left_to_write);
|
||||
|
||||
if (bytes_written != bytes_left_to_write)
|
||||
return MZ_WRITE_ERROR;
|
||||
|
||||
buffered->writebuf_misses += 1;
|
||||
|
||||
mz_stream_buffered_print("Buffered - Write flush (%" PRId32 ":%" PRId32 " len %" PRId32 ")\n",
|
||||
bytes_to_write, bytes_left_to_write, buffered->writebuf_len);
|
||||
|
||||
total_bytes_written += bytes_written;
|
||||
bytes_left_to_write -= bytes_written;
|
||||
buffered->position += bytes_written;
|
||||
}
|
||||
|
||||
buffered->writebuf_len = 0;
|
||||
buffered->writebuf_pos = 0;
|
||||
|
||||
*written = total_bytes_written;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_buffered_read(void *stream, void *buf, int32_t size) {
|
||||
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
|
||||
int32_t buf_len = 0;
|
||||
int32_t bytes_to_read = 0;
|
||||
int32_t bytes_to_copy = 0;
|
||||
int32_t bytes_left_to_read = size;
|
||||
int32_t bytes_read = 0;
|
||||
int32_t bytes_flushed = 0;
|
||||
|
||||
mz_stream_buffered_print("Buffered - Read (size %" PRId32 " pos %" PRId64 ")\n", size, buffered->position);
|
||||
|
||||
if (buffered->writebuf_len > 0) {
|
||||
int64_t position = buffered->position + buffered->writebuf_pos
|
||||
|
||||
mz_stream_buffered_print("Buffered - Switch from write to read, flushing (pos %" PRId64 ")\n", position);
|
||||
|
||||
mz_stream_buffered_flush(stream, &bytes_flushed);
|
||||
mz_stream_buffered_seek(stream, position, MZ_SEEK_SET);
|
||||
}
|
||||
|
||||
while (bytes_left_to_read > 0) {
|
||||
if ((buffered->readbuf_len == 0) || (buffered->readbuf_pos == buffered->readbuf_len)) {
|
||||
if (buffered->readbuf_len == sizeof(buffered->readbuf)) {
|
||||
buffered->readbuf_pos = 0;
|
||||
buffered->readbuf_len = 0;
|
||||
}
|
||||
|
||||
bytes_to_read = (int32_t)sizeof(buffered->readbuf) - (buffered->readbuf_len - buffered->readbuf_pos);
|
||||
bytes_read = mz_stream_read(buffered->stream.base, buffered->readbuf + buffered->readbuf_pos, bytes_to_read);
|
||||
if (bytes_read < 0)
|
||||
return bytes_read;
|
||||
|
||||
buffered->readbuf_misses += 1;
|
||||
buffered->readbuf_len += bytes_read;
|
||||
buffered->position += bytes_read;
|
||||
|
||||
mz_stream_buffered_print("Buffered - Filled (read %" PRId32 "/%" PRId32 " buf %" PRId32 ":%" PRId32 " pos %" PRId64 ")\n",
|
||||
bytes_read, bytes_to_read, buffered->readbuf_pos, buffered->readbuf_len, buffered->position);
|
||||
|
||||
if (bytes_read == 0)
|
||||
break;
|
||||
}
|
||||
|
||||
if ((buffered->readbuf_len - buffered->readbuf_pos) > 0) {
|
||||
bytes_to_copy = buffered->readbuf_len - buffered->readbuf_pos;
|
||||
if (bytes_to_copy > bytes_left_to_read)
|
||||
bytes_to_copy = bytes_left_to_read;
|
||||
|
||||
memcpy((char *)buf + buf_len, buffered->readbuf + buffered->readbuf_pos, bytes_to_copy);
|
||||
|
||||
buf_len += bytes_to_copy;
|
||||
bytes_left_to_read -= bytes_to_copy;
|
||||
|
||||
buffered->readbuf_hits += 1;
|
||||
buffered->readbuf_pos += bytes_to_copy;
|
||||
|
||||
mz_stream_buffered_print("Buffered - Emptied (copied %" PRId32 " remaining %" PRId32 " buf %" PRId32 ":%" PRId32 " pos %" PRId64 ")\n",
|
||||
bytes_to_copy, bytes_left_to_read, buffered->readbuf_pos, buffered->readbuf_len, buffered->position);
|
||||
}
|
||||
}
|
||||
|
||||
return size - bytes_left_to_read;
|
||||
}
|
||||
|
||||
int32_t mz_stream_buffered_write(void *stream, const void *buf, int32_t size) {
|
||||
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
|
||||
int32_t bytes_to_write = size;
|
||||
int32_t bytes_left_to_write = size;
|
||||
int32_t bytes_to_copy = 0;
|
||||
int32_t bytes_used = 0;
|
||||
int32_t bytes_flushed = 0;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
|
||||
mz_stream_buffered_print("Buffered - Write (size %" PRId32 " len %" PRId32 " pos %" PRId64 ")\n",
|
||||
size, buffered->writebuf_len, buffered->position);
|
||||
|
||||
if (buffered->readbuf_len > 0) {
|
||||
buffered->position -= buffered->readbuf_len;
|
||||
buffered->position += buffered->readbuf_pos;
|
||||
|
||||
buffered->readbuf_len = 0;
|
||||
buffered->readbuf_pos = 0;
|
||||
|
||||
mz_stream_buffered_print("Buffered - Switch from read to write (pos %" PRId64 ")\n", buffered->position);
|
||||
|
||||
err = mz_stream_seek(buffered->stream.base, buffered->position, MZ_SEEK_SET);
|
||||
if (err != MZ_OK)
|
||||
return err;
|
||||
}
|
||||
|
||||
while (bytes_left_to_write > 0) {
|
||||
bytes_used = buffered->writebuf_len;
|
||||
if (bytes_used > buffered->writebuf_pos)
|
||||
bytes_used = buffered->writebuf_pos;
|
||||
bytes_to_copy = (int32_t)sizeof(buffered->writebuf) - bytes_used;
|
||||
if (bytes_to_copy > bytes_left_to_write)
|
||||
bytes_to_copy = bytes_left_to_write;
|
||||
|
||||
if (bytes_to_copy == 0) {
|
||||
err = mz_stream_buffered_flush(stream, &bytes_flushed);
|
||||
if (err != MZ_OK)
|
||||
return err;
|
||||
if (bytes_flushed == 0)
|
||||
return 0;
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
memcpy(buffered->writebuf + buffered->writebuf_pos,
|
||||
(const char *)buf + (bytes_to_write - bytes_left_to_write), bytes_to_copy);
|
||||
|
||||
mz_stream_buffered_print("Buffered - Write copy (remaining %" PRId32 " write %" PRId32 ":%" PRId32 " len %" PRId32 ")\n",
|
||||
bytes_to_copy, bytes_to_write, bytes_left_to_write, buffered->writebuf_len);
|
||||
|
||||
bytes_left_to_write -= bytes_to_copy;
|
||||
|
||||
buffered->writebuf_pos += bytes_to_copy;
|
||||
buffered->writebuf_hits += 1;
|
||||
if (buffered->writebuf_pos > buffered->writebuf_len)
|
||||
buffered->writebuf_len += buffered->writebuf_pos - buffered->writebuf_len;
|
||||
}
|
||||
|
||||
return size - bytes_left_to_write;
|
||||
}
|
||||
|
||||
int64_t mz_stream_buffered_tell(void *stream) {
|
||||
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
|
||||
int64_t position = mz_stream_tell(buffered->stream.base);
|
||||
|
||||
buffered->position = position;
|
||||
|
||||
mz_stream_buffered_print("Buffered - Tell (pos %" PRId64 " readpos %" PRId32 " writepos %" PRId32 ")\n",
|
||||
buffered->position, buffered->readbuf_pos, buffered->writebuf_pos);
|
||||
|
||||
if (buffered->readbuf_len > 0)
|
||||
position -= ((int64_t)buffered->readbuf_len - buffered->readbuf_pos);
|
||||
if (buffered->writebuf_len > 0)
|
||||
position += buffered->writebuf_pos;
|
||||
return position;
|
||||
}
|
||||
|
||||
int32_t mz_stream_buffered_seek(void *stream, int64_t offset, int32_t origin) {
|
||||
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
|
||||
int32_t bytes_flushed = 0;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
mz_stream_buffered_print("Buffered - Seek (origin %" PRId32 " offset %" PRId64 " pos %" PRId64 ")\n",
|
||||
origin, offset, buffered->position);
|
||||
|
||||
switch (origin) {
|
||||
case MZ_SEEK_SET:
|
||||
|
||||
if ((buffered->readbuf_len > 0) && (offset < buffered->position) &&
|
||||
(offset >= buffered->position - buffered->readbuf_len)) {
|
||||
buffered->readbuf_pos = (int32_t)(offset - (buffered->position - buffered->readbuf_len));
|
||||
return MZ_OK;
|
||||
}
|
||||
if (buffered->writebuf_len > 0) {
|
||||
if ((offset >= buffered->position) && (offset <= buffered->position + buffered->writebuf_len)) {
|
||||
buffered->writebuf_pos = (int32_t)(offset - buffered->position);
|
||||
return MZ_OK;
|
||||
}
|
||||
}
|
||||
|
||||
err = mz_stream_buffered_flush(stream, &bytes_flushed);
|
||||
if (err != MZ_OK)
|
||||
return err;
|
||||
|
||||
buffered->position = offset;
|
||||
break;
|
||||
|
||||
case MZ_SEEK_CUR:
|
||||
|
||||
if (buffered->readbuf_len > 0) {
|
||||
if (offset <= ((int64_t)buffered->readbuf_len - buffered->readbuf_pos)) {
|
||||
buffered->readbuf_pos += (uint32_t)offset;
|
||||
return MZ_OK;
|
||||
}
|
||||
offset -= ((int64_t)buffered->readbuf_len - buffered->readbuf_pos);
|
||||
buffered->position += offset;
|
||||
}
|
||||
if (buffered->writebuf_len > 0) {
|
||||
if (offset <= ((int64_t)buffered->writebuf_len - buffered->writebuf_pos)) {
|
||||
buffered->writebuf_pos += (uint32_t)offset;
|
||||
return MZ_OK;
|
||||
}
|
||||
/* offset -= (buffered->writebuf_len - buffered->writebuf_pos); */
|
||||
}
|
||||
|
||||
err = mz_stream_buffered_flush(stream, &bytes_flushed);
|
||||
if (err != MZ_OK)
|
||||
return err;
|
||||
|
||||
break;
|
||||
|
||||
case MZ_SEEK_END:
|
||||
|
||||
if (buffered->writebuf_len > 0) {
|
||||
buffered->writebuf_pos = buffered->writebuf_len;
|
||||
return MZ_OK;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
buffered->readbuf_len = 0;
|
||||
buffered->readbuf_pos = 0;
|
||||
buffered->writebuf_len = 0;
|
||||
buffered->writebuf_pos = 0;
|
||||
|
||||
return mz_stream_seek(buffered->stream.base, offset, origin);
|
||||
}
|
||||
|
||||
int32_t mz_stream_buffered_close(void *stream) {
|
||||
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
|
||||
int32_t bytes_flushed = 0;
|
||||
|
||||
mz_stream_buffered_flush(stream, &bytes_flushed);
|
||||
mz_stream_buffered_print("Buffered - Close (flushed %" PRId32 ")\n", bytes_flushed);
|
||||
|
||||
if (buffered->readbuf_hits + buffered->readbuf_misses > 0) {
|
||||
mz_stream_buffered_print("Buffered - Read efficiency %.02f%%\n",
|
||||
(buffered->readbuf_hits / ((float)buffered->readbuf_hits + buffered->readbuf_misses)) * 100);
|
||||
}
|
||||
|
||||
if (buffered->writebuf_hits + buffered->writebuf_misses > 0) {
|
||||
mz_stream_buffered_print("Buffered - Write efficiency %.02f%%\n",
|
||||
(buffered->writebuf_hits / ((float)buffered->writebuf_hits + buffered->writebuf_misses)) * 100);
|
||||
}
|
||||
|
||||
mz_stream_buffered_reset(buffered);
|
||||
|
||||
return mz_stream_close(buffered->stream.base);
|
||||
}
|
||||
|
||||
int32_t mz_stream_buffered_error(void *stream) {
|
||||
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
|
||||
return mz_stream_error(buffered->stream.base);
|
||||
}
|
||||
|
||||
void *mz_stream_buffered_create(void **stream) {
|
||||
mz_stream_buffered *buffered = NULL;
|
||||
|
||||
buffered = (mz_stream_buffered *)MZ_ALLOC(sizeof(mz_stream_buffered));
|
||||
if (buffered != NULL) {
|
||||
memset(buffered, 0, sizeof(mz_stream_buffered));
|
||||
buffered->stream.vtbl = &mz_stream_buffered_vtbl;
|
||||
}
|
||||
if (stream != NULL)
|
||||
*stream = buffered;
|
||||
|
||||
return buffered;
|
||||
}
|
||||
|
||||
void mz_stream_buffered_delete(void **stream) {
|
||||
mz_stream_buffered *buffered = NULL;
|
||||
if (stream == NULL)
|
||||
return;
|
||||
buffered = (mz_stream_buffered *)*stream;
|
||||
if (buffered != NULL)
|
||||
MZ_FREE(buffered);
|
||||
*stream = NULL;
|
||||
}
|
||||
|
||||
void *mz_stream_buffered_get_interface(void) {
|
||||
return (void *)&mz_stream_buffered_vtbl;
|
||||
}
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
/* mz_strm_buf.h -- Stream for buffering reads/writes
|
||||
part of the minizip-ng project
|
||||
|
||||
This version of ioapi is designed to buffer IO.
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
#ifndef MZ_STREAM_BUFFERED_H
|
||||
#define MZ_STREAM_BUFFERED_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_stream_buffered_open(void *stream, const char *path, int32_t mode);
|
||||
int32_t mz_stream_buffered_is_open(void *stream);
|
||||
int32_t mz_stream_buffered_read(void *stream, void *buf, int32_t size);
|
||||
int32_t mz_stream_buffered_write(void *stream, const void *buf, int32_t size);
|
||||
int64_t mz_stream_buffered_tell(void *stream);
|
||||
int32_t mz_stream_buffered_seek(void *stream, int64_t offset, int32_t origin);
|
||||
int32_t mz_stream_buffered_close(void *stream);
|
||||
int32_t mz_stream_buffered_error(void *stream);
|
||||
|
||||
void* mz_stream_buffered_create(void **stream);
|
||||
void mz_stream_buffered_delete(void **stream);
|
||||
|
||||
void* mz_stream_buffered_get_interface(void);
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,272 @@
|
|||
/* mz_strm_mem.c -- Stream for memory access
|
||||
part of the minizip-ng project
|
||||
|
||||
This interface is designed to access memory rather than files.
|
||||
We do use a region of memory to put data in to and take it out of.
|
||||
|
||||
Based on Unzip ioapi.c version 0.22, May 19th, 2003
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
Copyright (C) 2003 Justin Fletcher
|
||||
Copyright (C) 1998-2003 Gilles Vollant
|
||||
https://www.winimage.com/zLibDll/minizip.html
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
|
||||
#include "mz.h"
|
||||
#include "mz_strm.h"
|
||||
#include "mz_strm_mem.h"
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
static mz_stream_vtbl mz_stream_mem_vtbl = {
|
||||
mz_stream_mem_open,
|
||||
mz_stream_mem_is_open,
|
||||
mz_stream_mem_read,
|
||||
mz_stream_mem_write,
|
||||
mz_stream_mem_tell,
|
||||
mz_stream_mem_seek,
|
||||
mz_stream_mem_close,
|
||||
mz_stream_mem_error,
|
||||
mz_stream_mem_create,
|
||||
mz_stream_mem_delete,
|
||||
NULL,
|
||||
NULL
|
||||
};
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
typedef struct mz_stream_mem_s {
|
||||
mz_stream stream;
|
||||
int32_t mode;
|
||||
uint8_t *buffer; /* Memory buffer pointer */
|
||||
int32_t size; /* Size of the memory buffer */
|
||||
int32_t limit; /* Furthest we've written */
|
||||
int32_t position; /* Current position in the memory */
|
||||
int32_t grow_size; /* Size to grow when full */
|
||||
} mz_stream_mem;
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
static int32_t mz_stream_mem_set_size(void *stream, int32_t size) {
|
||||
mz_stream_mem *mem = (mz_stream_mem *)stream;
|
||||
int32_t new_size = size;
|
||||
uint8_t *new_buf = NULL;
|
||||
|
||||
|
||||
new_buf = (uint8_t *)MZ_ALLOC((uint32_t)new_size);
|
||||
if (new_buf == NULL)
|
||||
return MZ_BUF_ERROR;
|
||||
|
||||
if (mem->buffer) {
|
||||
memcpy(new_buf, mem->buffer, mem->size);
|
||||
MZ_FREE(mem->buffer);
|
||||
}
|
||||
|
||||
mem->buffer = new_buf;
|
||||
mem->size = new_size;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_mem_open(void *stream, const char *path, int32_t mode) {
|
||||
mz_stream_mem *mem = (mz_stream_mem *)stream;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
MZ_UNUSED(path);
|
||||
|
||||
mem->mode = mode;
|
||||
mem->limit = 0;
|
||||
mem->position = 0;
|
||||
|
||||
if (mem->mode & MZ_OPEN_MODE_CREATE)
|
||||
err = mz_stream_mem_set_size(stream, mem->grow_size);
|
||||
else
|
||||
mem->limit = mem->size;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
int32_t mz_stream_mem_is_open(void *stream) {
|
||||
mz_stream_mem *mem = (mz_stream_mem *)stream;
|
||||
if (mem->buffer == NULL)
|
||||
return MZ_OPEN_ERROR;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_mem_read(void *stream, void *buf, int32_t size) {
|
||||
mz_stream_mem *mem = (mz_stream_mem *)stream;
|
||||
|
||||
if (size > mem->size - mem->position)
|
||||
size = mem->size - mem->position;
|
||||
if (mem->position + size > mem->limit)
|
||||
size = mem->limit - mem->position;
|
||||
|
||||
if (size <= 0)
|
||||
return 0;
|
||||
|
||||
memcpy(buf, mem->buffer + mem->position, size);
|
||||
mem->position += size;
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
int32_t mz_stream_mem_write(void *stream, const void *buf, int32_t size) {
|
||||
mz_stream_mem *mem = (mz_stream_mem *)stream;
|
||||
int32_t new_size = 0;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
if (size == 0)
|
||||
return size;
|
||||
|
||||
if (size > mem->size - mem->position) {
|
||||
if (mem->mode & MZ_OPEN_MODE_CREATE) {
|
||||
new_size = mem->size;
|
||||
if (size < mem->grow_size)
|
||||
new_size += mem->grow_size;
|
||||
else
|
||||
new_size += size;
|
||||
|
||||
err = mz_stream_mem_set_size(stream, new_size);
|
||||
if (err != MZ_OK)
|
||||
return err;
|
||||
} else {
|
||||
size = mem->size - mem->position;
|
||||
}
|
||||
}
|
||||
|
||||
memcpy(mem->buffer + mem->position, buf, size);
|
||||
|
||||
mem->position += size;
|
||||
if (mem->position > mem->limit)
|
||||
mem->limit = mem->position;
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
int64_t mz_stream_mem_tell(void *stream) {
|
||||
mz_stream_mem *mem = (mz_stream_mem *)stream;
|
||||
return mem->position;
|
||||
}
|
||||
|
||||
int32_t mz_stream_mem_seek(void *stream, int64_t offset, int32_t origin) {
|
||||
mz_stream_mem *mem = (mz_stream_mem *)stream;
|
||||
int64_t new_pos = 0;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
switch (origin) {
|
||||
case MZ_SEEK_CUR:
|
||||
new_pos = mem->position + offset;
|
||||
break;
|
||||
case MZ_SEEK_END:
|
||||
new_pos = mem->limit + offset;
|
||||
break;
|
||||
case MZ_SEEK_SET:
|
||||
new_pos = offset;
|
||||
break;
|
||||
default:
|
||||
return MZ_SEEK_ERROR;
|
||||
}
|
||||
|
||||
if (new_pos > mem->size) {
|
||||
if ((mem->mode & MZ_OPEN_MODE_CREATE) == 0)
|
||||
return MZ_SEEK_ERROR;
|
||||
|
||||
err = mz_stream_mem_set_size(stream, (int32_t)new_pos);
|
||||
if (err != MZ_OK)
|
||||
return err;
|
||||
} else if (new_pos < 0) {
|
||||
return MZ_SEEK_ERROR;
|
||||
}
|
||||
|
||||
mem->position = (int32_t)new_pos;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_mem_close(void *stream) {
|
||||
MZ_UNUSED(stream);
|
||||
|
||||
/* We never return errors */
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_mem_error(void *stream) {
|
||||
MZ_UNUSED(stream);
|
||||
|
||||
/* We never return errors */
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
void mz_stream_mem_set_buffer(void *stream, void *buf, int32_t size) {
|
||||
mz_stream_mem *mem = (mz_stream_mem *)stream;
|
||||
mem->buffer = (uint8_t *)buf;
|
||||
mem->size = size;
|
||||
mem->limit = size;
|
||||
}
|
||||
|
||||
int32_t mz_stream_mem_get_buffer(void *stream, const void **buf) {
|
||||
return mz_stream_mem_get_buffer_at(stream, 0, buf);
|
||||
}
|
||||
|
||||
int32_t mz_stream_mem_get_buffer_at(void *stream, int64_t position, const void **buf) {
|
||||
mz_stream_mem *mem = (mz_stream_mem *)stream;
|
||||
if (buf == NULL || position < 0 || mem->size < position || mem->buffer == NULL)
|
||||
return MZ_SEEK_ERROR;
|
||||
*buf = mem->buffer + position;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_mem_get_buffer_at_current(void *stream, const void **buf) {
|
||||
mz_stream_mem *mem = (mz_stream_mem *)stream;
|
||||
return mz_stream_mem_get_buffer_at(stream, mem->position, buf);
|
||||
}
|
||||
|
||||
void mz_stream_mem_get_buffer_length(void *stream, int32_t *length) {
|
||||
mz_stream_mem *mem = (mz_stream_mem *)stream;
|
||||
*length = mem->limit;
|
||||
}
|
||||
|
||||
void mz_stream_mem_set_buffer_limit(void *stream, int32_t limit) {
|
||||
mz_stream_mem *mem = (mz_stream_mem *)stream;
|
||||
mem->limit = limit;
|
||||
}
|
||||
|
||||
void mz_stream_mem_set_grow_size(void *stream, int32_t grow_size) {
|
||||
mz_stream_mem *mem = (mz_stream_mem *)stream;
|
||||
mem->grow_size = grow_size;
|
||||
}
|
||||
|
||||
void *mz_stream_mem_create(void **stream) {
|
||||
mz_stream_mem *mem = NULL;
|
||||
|
||||
mem = (mz_stream_mem *)MZ_ALLOC(sizeof(mz_stream_mem));
|
||||
if (mem != NULL) {
|
||||
memset(mem, 0, sizeof(mz_stream_mem));
|
||||
mem->stream.vtbl = &mz_stream_mem_vtbl;
|
||||
mem->grow_size = 4096;
|
||||
}
|
||||
if (stream != NULL)
|
||||
*stream = mem;
|
||||
|
||||
return mem;
|
||||
}
|
||||
|
||||
void mz_stream_mem_delete(void **stream) {
|
||||
mz_stream_mem *mem = NULL;
|
||||
if (stream == NULL)
|
||||
return;
|
||||
mem = (mz_stream_mem *)*stream;
|
||||
if (mem != NULL) {
|
||||
if ((mem->mode & MZ_OPEN_MODE_CREATE) && (mem->buffer != NULL))
|
||||
MZ_FREE(mem->buffer);
|
||||
MZ_FREE(mem);
|
||||
}
|
||||
*stream = NULL;
|
||||
}
|
||||
|
||||
void *mz_stream_mem_get_interface(void) {
|
||||
return (void *)&mz_stream_mem_vtbl;
|
||||
}
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
/* mz_strm_mem.h -- Stream for memory access
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
#ifndef MZ_STREAM_MEM_H
|
||||
#define MZ_STREAM_MEM_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_stream_mem_open(void *stream, const char *filename, int32_t mode);
|
||||
int32_t mz_stream_mem_is_open(void *stream);
|
||||
int32_t mz_stream_mem_read(void *stream, void *buf, int32_t size);
|
||||
int32_t mz_stream_mem_write(void *stream, const void *buf, int32_t size);
|
||||
int64_t mz_stream_mem_tell(void *stream);
|
||||
int32_t mz_stream_mem_seek(void *stream, int64_t offset, int32_t origin);
|
||||
int32_t mz_stream_mem_close(void *stream);
|
||||
int32_t mz_stream_mem_error(void *stream);
|
||||
|
||||
void mz_stream_mem_set_buffer(void *stream, void *buf, int32_t size);
|
||||
int32_t mz_stream_mem_get_buffer(void *stream, const void **buf);
|
||||
int32_t mz_stream_mem_get_buffer_at(void *stream, int64_t position, const void **buf);
|
||||
int32_t mz_stream_mem_get_buffer_at_current(void *stream, const void **buf);
|
||||
void mz_stream_mem_get_buffer_length(void *stream, int32_t *length);
|
||||
void mz_stream_mem_set_buffer_limit(void *stream, int32_t limit);
|
||||
void mz_stream_mem_set_grow_size(void *stream, int32_t grow_size);
|
||||
|
||||
void* mz_stream_mem_create(void **stream);
|
||||
void mz_stream_mem_delete(void **stream);
|
||||
|
||||
void* mz_stream_mem_get_interface(void);
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
/* mz_sstrm_os.h -- Stream for filesystem access
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
#ifndef MZ_STREAM_OS_H
|
||||
#define MZ_STREAM_OS_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_stream_os_open(void *stream, const char *path, int32_t mode);
|
||||
int32_t mz_stream_os_is_open(void *stream);
|
||||
int32_t mz_stream_os_read(void *stream, void *buf, int32_t size);
|
||||
int32_t mz_stream_os_write(void *stream, const void *buf, int32_t size);
|
||||
int64_t mz_stream_os_tell(void *stream);
|
||||
int32_t mz_stream_os_seek(void *stream, int64_t offset, int32_t origin);
|
||||
int32_t mz_stream_os_close(void *stream);
|
||||
int32_t mz_stream_os_error(void *stream);
|
||||
|
||||
void* mz_stream_os_create(void **stream);
|
||||
void mz_stream_os_delete(void **stream);
|
||||
|
||||
void* mz_stream_os_get_interface(void);
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,206 @@
|
|||
/* mz_strm_posix.c -- Stream for filesystem access for posix/linux
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
Modifications for Zip64 support
|
||||
Copyright (C) 2009-2010 Mathias Svensson
|
||||
http://result42.com
|
||||
Copyright (C) 1998-2010 Gilles Vollant
|
||||
https://www.winimage.com/zLibDll/minizip.html
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
|
||||
#include "mz.h"
|
||||
#include "mz_strm.h"
|
||||
#include "mz_strm_os.h"
|
||||
|
||||
#include <stdio.h> /* fopen, fread.. */
|
||||
#include <errno.h>
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#define fopen64 fopen
|
||||
#ifndef MZ_FILE32_API
|
||||
# ifndef NO_FSEEKO
|
||||
# define ftello64 ftello
|
||||
# define fseeko64 fseeko
|
||||
# elif defined(_MSC_VER) && (_MSC_VER >= 1400)
|
||||
# define ftello64 _ftelli64
|
||||
# define fseeko64 _fseeki64
|
||||
# endif
|
||||
#endif
|
||||
#ifndef ftello64
|
||||
# define ftello64 ftell
|
||||
#endif
|
||||
#ifndef fseeko64
|
||||
# define fseeko64 fseek
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
static mz_stream_vtbl mz_stream_os_vtbl = {
|
||||
mz_stream_os_open,
|
||||
mz_stream_os_is_open,
|
||||
mz_stream_os_read,
|
||||
mz_stream_os_write,
|
||||
mz_stream_os_tell,
|
||||
mz_stream_os_seek,
|
||||
mz_stream_os_close,
|
||||
mz_stream_os_error,
|
||||
mz_stream_os_create,
|
||||
mz_stream_os_delete,
|
||||
NULL,
|
||||
NULL
|
||||
};
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
typedef struct mz_stream_posix_s {
|
||||
mz_stream stream;
|
||||
int32_t error;
|
||||
FILE *handle;
|
||||
} mz_stream_posix;
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_stream_os_open(void *stream, const char *path, int32_t mode) {
|
||||
mz_stream_posix *posix = (mz_stream_posix *)stream;
|
||||
const char *mode_fopen = NULL;
|
||||
|
||||
if (path == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
if ((mode & MZ_OPEN_MODE_READWRITE) == MZ_OPEN_MODE_READ)
|
||||
mode_fopen = "rb";
|
||||
else if (mode & MZ_OPEN_MODE_APPEND)
|
||||
mode_fopen = "r+b";
|
||||
else if (mode & MZ_OPEN_MODE_CREATE)
|
||||
mode_fopen = "wb";
|
||||
else
|
||||
return MZ_OPEN_ERROR;
|
||||
|
||||
posix->handle = fopen64(path, mode_fopen);
|
||||
if (posix->handle == NULL) {
|
||||
posix->error = errno;
|
||||
return MZ_OPEN_ERROR;
|
||||
}
|
||||
|
||||
if (mode & MZ_OPEN_MODE_APPEND)
|
||||
return mz_stream_os_seek(stream, 0, MZ_SEEK_END);
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_os_is_open(void *stream) {
|
||||
mz_stream_posix *posix = (mz_stream_posix*)stream;
|
||||
if (posix->handle == NULL)
|
||||
return MZ_OPEN_ERROR;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_os_read(void *stream, void *buf, int32_t size) {
|
||||
mz_stream_posix *posix = (mz_stream_posix*)stream;
|
||||
int32_t read = (int32_t)fread(buf, 1, (size_t)size, posix->handle);
|
||||
if (read < size && ferror(posix->handle)) {
|
||||
posix->error = errno;
|
||||
return MZ_READ_ERROR;
|
||||
}
|
||||
return read;
|
||||
}
|
||||
|
||||
int32_t mz_stream_os_write(void *stream, const void *buf, int32_t size) {
|
||||
mz_stream_posix *posix = (mz_stream_posix*)stream;
|
||||
int32_t written = (int32_t)fwrite(buf, 1, (size_t)size, posix->handle);
|
||||
if (written < size && ferror(posix->handle)) {
|
||||
posix->error = errno;
|
||||
return MZ_WRITE_ERROR;
|
||||
}
|
||||
return written;
|
||||
}
|
||||
|
||||
int64_t mz_stream_os_tell(void *stream) {
|
||||
mz_stream_posix *posix = (mz_stream_posix*)stream;
|
||||
int64_t position = ftello64(posix->handle);
|
||||
if (position == -1) {
|
||||
posix->error = errno;
|
||||
return MZ_TELL_ERROR;
|
||||
}
|
||||
return position;
|
||||
}
|
||||
|
||||
int32_t mz_stream_os_seek(void *stream, int64_t offset, int32_t origin) {
|
||||
mz_stream_posix *posix = (mz_stream_posix*)stream;
|
||||
int32_t fseek_origin = 0;
|
||||
|
||||
switch (origin) {
|
||||
case MZ_SEEK_CUR:
|
||||
fseek_origin = SEEK_CUR;
|
||||
break;
|
||||
case MZ_SEEK_END:
|
||||
fseek_origin = SEEK_END;
|
||||
break;
|
||||
case MZ_SEEK_SET:
|
||||
fseek_origin = SEEK_SET;
|
||||
break;
|
||||
default:
|
||||
return MZ_SEEK_ERROR;
|
||||
}
|
||||
|
||||
if (fseeko64(posix->handle, offset, fseek_origin) != 0) {
|
||||
posix->error = errno;
|
||||
return MZ_SEEK_ERROR;
|
||||
}
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_os_close(void *stream) {
|
||||
mz_stream_posix *posix = (mz_stream_posix*)stream;
|
||||
int32_t closed = 0;
|
||||
if (posix->handle != NULL) {
|
||||
closed = fclose(posix->handle);
|
||||
posix->handle = NULL;
|
||||
}
|
||||
if (closed != 0) {
|
||||
posix->error = errno;
|
||||
return MZ_CLOSE_ERROR;
|
||||
}
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_os_error(void *stream) {
|
||||
mz_stream_posix *posix = (mz_stream_posix*)stream;
|
||||
return posix->error;
|
||||
}
|
||||
|
||||
void *mz_stream_os_create(void **stream) {
|
||||
mz_stream_posix *posix = NULL;
|
||||
|
||||
posix = (mz_stream_posix *)MZ_ALLOC(sizeof(mz_stream_posix));
|
||||
if (posix != NULL) {
|
||||
memset(posix, 0, sizeof(mz_stream_posix));
|
||||
posix->stream.vtbl = &mz_stream_os_vtbl;
|
||||
}
|
||||
if (stream != NULL)
|
||||
*stream = posix;
|
||||
|
||||
return posix;
|
||||
}
|
||||
|
||||
void mz_stream_os_delete(void **stream) {
|
||||
mz_stream_posix *posix = NULL;
|
||||
if (stream == NULL)
|
||||
return;
|
||||
posix = (mz_stream_posix *)*stream;
|
||||
if (posix != NULL)
|
||||
MZ_FREE(posix);
|
||||
*stream = NULL;
|
||||
}
|
||||
|
||||
void *mz_stream_os_get_interface(void) {
|
||||
return (void *)&mz_stream_os_vtbl;
|
||||
}
|
||||
|
|
@ -0,0 +1,338 @@
|
|||
/* mz_strm_pkcrypt.c -- Code for traditional PKWARE encryption
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
Copyright (C) 1998-2005 Gilles Vollant
|
||||
Modifications for Info-ZIP crypting
|
||||
https://www.winimage.com/zLibDll/minizip.html
|
||||
Copyright (C) 2003 Terry Thorsen
|
||||
|
||||
This code is a modified version of crypting code in Info-ZIP distribution
|
||||
|
||||
Copyright (C) 1990-2000 Info-ZIP. All rights reserved.
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
|
||||
This encryption code is a direct transcription of the algorithm from
|
||||
Roger Schlafly, described by Phil Katz in the file appnote.txt. This
|
||||
file (appnote.txt) is distributed with the PKZIP program (even in the
|
||||
version without encryption capabilities).
|
||||
*/
|
||||
|
||||
|
||||
#include "mz.h"
|
||||
#include "mz_crypt.h"
|
||||
#include "mz_strm.h"
|
||||
#include "mz_strm_pkcrypt.h"
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
static mz_stream_vtbl mz_stream_pkcrypt_vtbl = {
|
||||
mz_stream_pkcrypt_open,
|
||||
mz_stream_pkcrypt_is_open,
|
||||
mz_stream_pkcrypt_read,
|
||||
mz_stream_pkcrypt_write,
|
||||
mz_stream_pkcrypt_tell,
|
||||
mz_stream_pkcrypt_seek,
|
||||
mz_stream_pkcrypt_close,
|
||||
mz_stream_pkcrypt_error,
|
||||
mz_stream_pkcrypt_create,
|
||||
mz_stream_pkcrypt_delete,
|
||||
mz_stream_pkcrypt_get_prop_int64,
|
||||
mz_stream_pkcrypt_set_prop_int64
|
||||
};
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
typedef struct mz_stream_pkcrypt_s {
|
||||
mz_stream stream;
|
||||
int32_t error;
|
||||
int16_t initialized;
|
||||
uint8_t buffer[UINT16_MAX];
|
||||
int64_t total_in;
|
||||
int64_t max_total_in;
|
||||
int64_t total_out;
|
||||
uint32_t keys[3]; /* keys defining the pseudo-random sequence */
|
||||
uint8_t verify1;
|
||||
uint8_t verify2;
|
||||
const char *password;
|
||||
} mz_stream_pkcrypt;
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#define mz_stream_pkcrypt_decode(strm, c) \
|
||||
(mz_stream_pkcrypt_update_keys(strm, \
|
||||
c ^= mz_stream_pkcrypt_decrypt_byte(strm)))
|
||||
|
||||
#define mz_stream_pkcrypt_encode(strm, c, t) \
|
||||
(t = mz_stream_pkcrypt_decrypt_byte(strm), \
|
||||
mz_stream_pkcrypt_update_keys(strm, (uint8_t)c), (uint8_t)(t^(c)))
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
static uint8_t mz_stream_pkcrypt_decrypt_byte(void *stream) {
|
||||
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
|
||||
|
||||
unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an */
|
||||
/* unpredictable manner on 16-bit systems; not a problem */
|
||||
/* with any known compiler so far, though. */
|
||||
|
||||
temp = pkcrypt->keys[2] | 2;
|
||||
return (uint8_t)(((temp * (temp ^ 1)) >> 8) & 0xff);
|
||||
}
|
||||
|
||||
static uint8_t mz_stream_pkcrypt_update_keys(void *stream, uint8_t c) {
|
||||
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
|
||||
uint8_t buf = c;
|
||||
|
||||
pkcrypt->keys[0] = (uint32_t)~mz_crypt_crc32_update(~pkcrypt->keys[0], &buf, 1);
|
||||
|
||||
pkcrypt->keys[1] += pkcrypt->keys[0] & 0xff;
|
||||
pkcrypt->keys[1] *= 134775813L;
|
||||
pkcrypt->keys[1] += 1;
|
||||
|
||||
buf = (uint8_t)(pkcrypt->keys[1] >> 24);
|
||||
pkcrypt->keys[2] = (uint32_t)~mz_crypt_crc32_update(~pkcrypt->keys[2], &buf, 1);
|
||||
|
||||
return (uint8_t)c;
|
||||
}
|
||||
|
||||
static void mz_stream_pkcrypt_init_keys(void *stream, const char *password) {
|
||||
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
|
||||
|
||||
pkcrypt->keys[0] = 305419896L;
|
||||
pkcrypt->keys[1] = 591751049L;
|
||||
pkcrypt->keys[2] = 878082192L;
|
||||
|
||||
while (*password != 0) {
|
||||
mz_stream_pkcrypt_update_keys(stream, (uint8_t)*password);
|
||||
password += 1;
|
||||
}
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_stream_pkcrypt_open(void *stream, const char *path, int32_t mode) {
|
||||
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
|
||||
uint16_t t = 0;
|
||||
int16_t i = 0;
|
||||
uint8_t verify1 = 0;
|
||||
uint8_t verify2 = 0;
|
||||
uint8_t header[MZ_PKCRYPT_HEADER_SIZE];
|
||||
const char *password = path;
|
||||
|
||||
pkcrypt->total_in = 0;
|
||||
pkcrypt->total_out = 0;
|
||||
pkcrypt->initialized = 0;
|
||||
|
||||
if (mz_stream_is_open(pkcrypt->stream.base) != MZ_OK)
|
||||
return MZ_OPEN_ERROR;
|
||||
|
||||
if (password == NULL)
|
||||
password = pkcrypt->password;
|
||||
if (password == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
mz_stream_pkcrypt_init_keys(stream, password);
|
||||
|
||||
if (mode & MZ_OPEN_MODE_WRITE) {
|
||||
/* First generate RAND_HEAD_LEN - 2 random bytes. */
|
||||
mz_crypt_rand(header, MZ_PKCRYPT_HEADER_SIZE - 2);
|
||||
|
||||
/* Encrypt random header (last two bytes is high word of crc) */
|
||||
for (i = 0; i < MZ_PKCRYPT_HEADER_SIZE - 2; i++)
|
||||
header[i] = mz_stream_pkcrypt_encode(stream, header[i], t);
|
||||
|
||||
header[i++] = mz_stream_pkcrypt_encode(stream, pkcrypt->verify1, t);
|
||||
header[i++] = mz_stream_pkcrypt_encode(stream, pkcrypt->verify2, t);
|
||||
|
||||
if (mz_stream_write(pkcrypt->stream.base, header, sizeof(header)) != sizeof(header))
|
||||
return MZ_WRITE_ERROR;
|
||||
|
||||
pkcrypt->total_out += MZ_PKCRYPT_HEADER_SIZE;
|
||||
} else if (mode & MZ_OPEN_MODE_READ) {
|
||||
if (mz_stream_read(pkcrypt->stream.base, header, sizeof(header)) != sizeof(header))
|
||||
return MZ_READ_ERROR;
|
||||
|
||||
for (i = 0; i < MZ_PKCRYPT_HEADER_SIZE - 2; i++)
|
||||
header[i] = mz_stream_pkcrypt_decode(stream, header[i]);
|
||||
|
||||
verify1 = mz_stream_pkcrypt_decode(stream, header[i++]);
|
||||
verify2 = mz_stream_pkcrypt_decode(stream, header[i++]);
|
||||
|
||||
/* Older versions used 2 byte check, newer versions use 1 byte check. */
|
||||
MZ_UNUSED(verify1);
|
||||
if ((verify2 != 0) && (verify2 != pkcrypt->verify2))
|
||||
return MZ_PASSWORD_ERROR;
|
||||
|
||||
pkcrypt->total_in += MZ_PKCRYPT_HEADER_SIZE;
|
||||
}
|
||||
|
||||
pkcrypt->initialized = 1;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_pkcrypt_is_open(void *stream) {
|
||||
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
|
||||
if (pkcrypt->initialized == 0)
|
||||
return MZ_OPEN_ERROR;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_pkcrypt_read(void *stream, void *buf, int32_t size) {
|
||||
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
|
||||
uint8_t *buf_ptr = (uint8_t *)buf;
|
||||
int32_t bytes_to_read = size;
|
||||
int32_t read = 0;
|
||||
int32_t i = 0;
|
||||
|
||||
|
||||
if ((int64_t)bytes_to_read > (pkcrypt->max_total_in - pkcrypt->total_in))
|
||||
bytes_to_read = (int32_t)(pkcrypt->max_total_in - pkcrypt->total_in);
|
||||
|
||||
read = mz_stream_read(pkcrypt->stream.base, buf, bytes_to_read);
|
||||
|
||||
for (i = 0; i < read; i++)
|
||||
buf_ptr[i] = mz_stream_pkcrypt_decode(stream, buf_ptr[i]);
|
||||
|
||||
if (read > 0)
|
||||
pkcrypt->total_in += read;
|
||||
|
||||
return read;
|
||||
}
|
||||
|
||||
int32_t mz_stream_pkcrypt_write(void *stream, const void *buf, int32_t size) {
|
||||
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
|
||||
const uint8_t *buf_ptr = (const uint8_t *)buf;
|
||||
int32_t bytes_to_write = sizeof(pkcrypt->buffer);
|
||||
int32_t total_written = 0;
|
||||
int32_t written = 0;
|
||||
int32_t i = 0;
|
||||
uint16_t t = 0;
|
||||
|
||||
if (size < 0)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
do {
|
||||
if (bytes_to_write > (size - total_written))
|
||||
bytes_to_write = (size - total_written);
|
||||
|
||||
for (i = 0; i < bytes_to_write; i += 1) {
|
||||
pkcrypt->buffer[i] = mz_stream_pkcrypt_encode(stream, *buf_ptr, t);
|
||||
buf_ptr += 1;
|
||||
}
|
||||
|
||||
written = mz_stream_write(pkcrypt->stream.base, pkcrypt->buffer, bytes_to_write);
|
||||
if (written < 0)
|
||||
return written;
|
||||
|
||||
total_written += written;
|
||||
} while (total_written < size && written > 0);
|
||||
|
||||
pkcrypt->total_out += total_written;
|
||||
return total_written;
|
||||
}
|
||||
|
||||
int64_t mz_stream_pkcrypt_tell(void *stream) {
|
||||
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
|
||||
return mz_stream_tell(pkcrypt->stream.base);
|
||||
}
|
||||
|
||||
int32_t mz_stream_pkcrypt_seek(void *stream, int64_t offset, int32_t origin) {
|
||||
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
|
||||
return mz_stream_seek(pkcrypt->stream.base, offset, origin);
|
||||
}
|
||||
|
||||
int32_t mz_stream_pkcrypt_close(void *stream) {
|
||||
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
|
||||
pkcrypt->initialized = 0;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_pkcrypt_error(void *stream) {
|
||||
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
|
||||
return pkcrypt->error;
|
||||
}
|
||||
|
||||
void mz_stream_pkcrypt_set_password(void *stream, const char *password) {
|
||||
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
|
||||
pkcrypt->password = password;
|
||||
}
|
||||
|
||||
void mz_stream_pkcrypt_set_verify(void *stream, uint8_t verify1, uint8_t verify2) {
|
||||
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
|
||||
pkcrypt->verify1 = verify1;
|
||||
pkcrypt->verify2 = verify2;
|
||||
}
|
||||
|
||||
void mz_stream_pkcrypt_get_verify(void *stream, uint8_t *verify1, uint8_t *verify2) {
|
||||
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
|
||||
*verify1 = pkcrypt->verify1;
|
||||
*verify2 = pkcrypt->verify2;
|
||||
}
|
||||
|
||||
int32_t mz_stream_pkcrypt_get_prop_int64(void *stream, int32_t prop, int64_t *value) {
|
||||
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
|
||||
switch (prop) {
|
||||
case MZ_STREAM_PROP_TOTAL_IN:
|
||||
*value = pkcrypt->total_in;
|
||||
break;
|
||||
case MZ_STREAM_PROP_TOTAL_OUT:
|
||||
*value = pkcrypt->total_out;
|
||||
break;
|
||||
case MZ_STREAM_PROP_TOTAL_IN_MAX:
|
||||
*value = pkcrypt->max_total_in;
|
||||
break;
|
||||
case MZ_STREAM_PROP_HEADER_SIZE:
|
||||
*value = MZ_PKCRYPT_HEADER_SIZE;
|
||||
break;
|
||||
case MZ_STREAM_PROP_FOOTER_SIZE:
|
||||
*value = 0;
|
||||
break;
|
||||
default:
|
||||
return MZ_EXIST_ERROR;
|
||||
}
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_pkcrypt_set_prop_int64(void *stream, int32_t prop, int64_t value) {
|
||||
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
|
||||
switch (prop) {
|
||||
case MZ_STREAM_PROP_TOTAL_IN_MAX:
|
||||
pkcrypt->max_total_in = value;
|
||||
break;
|
||||
default:
|
||||
return MZ_EXIST_ERROR;
|
||||
}
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
void *mz_stream_pkcrypt_create(void **stream) {
|
||||
mz_stream_pkcrypt *pkcrypt = NULL;
|
||||
|
||||
pkcrypt = (mz_stream_pkcrypt *)MZ_ALLOC(sizeof(mz_stream_pkcrypt));
|
||||
if (pkcrypt != NULL) {
|
||||
memset(pkcrypt, 0, sizeof(mz_stream_pkcrypt));
|
||||
pkcrypt->stream.vtbl = &mz_stream_pkcrypt_vtbl;
|
||||
}
|
||||
|
||||
if (stream != NULL)
|
||||
*stream = pkcrypt;
|
||||
return pkcrypt;
|
||||
}
|
||||
|
||||
void mz_stream_pkcrypt_delete(void **stream) {
|
||||
mz_stream_pkcrypt *pkcrypt = NULL;
|
||||
if (stream == NULL)
|
||||
return;
|
||||
pkcrypt = (mz_stream_pkcrypt *)*stream;
|
||||
if (pkcrypt != NULL)
|
||||
MZ_FREE(pkcrypt);
|
||||
*stream = NULL;
|
||||
}
|
||||
|
||||
void *mz_stream_pkcrypt_get_interface(void) {
|
||||
return (void *)&mz_stream_pkcrypt_vtbl;
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
/* mz_strm_pkcrypt.h -- Code for traditional PKWARE encryption
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
#ifndef MZ_STREAM_PKCRYPT_H
|
||||
#define MZ_STREAM_PKCRYPT_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_stream_pkcrypt_open(void *stream, const char *filename, int32_t mode);
|
||||
int32_t mz_stream_pkcrypt_is_open(void *stream);
|
||||
int32_t mz_stream_pkcrypt_read(void *stream, void *buf, int32_t size);
|
||||
int32_t mz_stream_pkcrypt_write(void *stream, const void *buf, int32_t size);
|
||||
int64_t mz_stream_pkcrypt_tell(void *stream);
|
||||
int32_t mz_stream_pkcrypt_seek(void *stream, int64_t offset, int32_t origin);
|
||||
int32_t mz_stream_pkcrypt_close(void *stream);
|
||||
int32_t mz_stream_pkcrypt_error(void *stream);
|
||||
|
||||
void mz_stream_pkcrypt_set_password(void *stream, const char *password);
|
||||
void mz_stream_pkcrypt_set_verify(void *stream, uint8_t verify1, uint8_t verify2);
|
||||
void mz_stream_pkcrypt_get_verify(void *stream, uint8_t *verify1, uint8_t *verify2);
|
||||
int32_t mz_stream_pkcrypt_get_prop_int64(void *stream, int32_t prop, int64_t *value);
|
||||
int32_t mz_stream_pkcrypt_set_prop_int64(void *stream, int32_t prop, int64_t value);
|
||||
|
||||
void* mz_stream_pkcrypt_create(void **stream);
|
||||
void mz_stream_pkcrypt_delete(void **stream);
|
||||
|
||||
void* mz_stream_pkcrypt_get_interface(void);
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,438 @@
|
|||
/* mz_strm_split.c -- Stream for split files
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
|
||||
#include "mz.h"
|
||||
#include "mz_os.h"
|
||||
#include "mz_strm.h"
|
||||
#include "mz_strm_split.h"
|
||||
|
||||
#include <stdio.h> /* snprintf */
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER < 1900)
|
||||
# define snprintf _snprintf
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#define MZ_ZIP_MAGIC_DISKHEADER (0x08074b50)
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
static mz_stream_vtbl mz_stream_split_vtbl = {
|
||||
mz_stream_split_open,
|
||||
mz_stream_split_is_open,
|
||||
mz_stream_split_read,
|
||||
mz_stream_split_write,
|
||||
mz_stream_split_tell,
|
||||
mz_stream_split_seek,
|
||||
mz_stream_split_close,
|
||||
mz_stream_split_error,
|
||||
mz_stream_split_create,
|
||||
mz_stream_split_delete,
|
||||
mz_stream_split_get_prop_int64,
|
||||
mz_stream_split_set_prop_int64
|
||||
};
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
typedef struct mz_stream_split_s {
|
||||
mz_stream stream;
|
||||
int32_t is_open;
|
||||
int64_t disk_size;
|
||||
int64_t total_in;
|
||||
int64_t total_in_disk;
|
||||
int64_t total_out;
|
||||
int64_t total_out_disk;
|
||||
int32_t mode;
|
||||
char *path_cd;
|
||||
uint32_t path_cd_size;
|
||||
char *path_disk;
|
||||
uint32_t path_disk_size;
|
||||
int32_t number_disk;
|
||||
int32_t current_disk;
|
||||
int64_t current_disk_size;
|
||||
int32_t reached_end;
|
||||
} mz_stream_split;
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#if 0
|
||||
# define mz_stream_split_print printf
|
||||
#else
|
||||
# define mz_stream_split_print(fmt,...)
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
static int32_t mz_stream_split_open_disk(void *stream, int32_t number_disk) {
|
||||
mz_stream_split *split = (mz_stream_split *)stream;
|
||||
uint32_t magic = 0;
|
||||
int64_t position = 0;
|
||||
int32_t i = 0;
|
||||
int32_t err = MZ_OK;
|
||||
int16_t disk_part = 0;
|
||||
|
||||
|
||||
/* Check if we are reading or writing a disk part or the cd disk */
|
||||
if (number_disk >= 0) {
|
||||
if ((split->mode & MZ_OPEN_MODE_WRITE) == 0)
|
||||
disk_part = MZ_OPEN_MODE_READ;
|
||||
else if (split->disk_size > 0)
|
||||
disk_part = MZ_OPEN_MODE_WRITE;
|
||||
}
|
||||
|
||||
/* Construct disk path */
|
||||
if (disk_part > 0) {
|
||||
for (i = (int32_t)strlen(split->path_disk) - 1; i >= 0; i -= 1) {
|
||||
if (split->path_disk[i] != '.')
|
||||
continue;
|
||||
snprintf(&split->path_disk[i], split->path_disk_size - (uint32_t)i,
|
||||
".z%02" PRId32, number_disk + 1);
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
strncpy(split->path_disk, split->path_cd, split->path_disk_size - 1);
|
||||
split->path_disk[split->path_disk_size - 1] = 0;
|
||||
}
|
||||
|
||||
mz_stream_split_print("Split - Goto disk - %s (disk %" PRId32 ")\n", split->path_disk, number_disk);
|
||||
|
||||
/* If disk part doesn't exist during reading then return MZ_EXIST_ERROR */
|
||||
if (disk_part == MZ_OPEN_MODE_READ)
|
||||
err = mz_os_file_exists(split->path_disk);
|
||||
|
||||
if (err == MZ_OK)
|
||||
err = mz_stream_open(split->stream.base, split->path_disk, split->mode);
|
||||
|
||||
if (err == MZ_OK) {
|
||||
split->total_in_disk = 0;
|
||||
split->total_out_disk = 0;
|
||||
split->current_disk = number_disk;
|
||||
|
||||
if (split->mode & MZ_OPEN_MODE_WRITE) {
|
||||
if ((split->current_disk == 0) && (split->disk_size > 0)) {
|
||||
err = mz_stream_write_uint32(split->stream.base, MZ_ZIP_MAGIC_DISKHEADER);
|
||||
|
||||
split->total_out_disk += 4;
|
||||
split->total_out += split->total_out_disk;
|
||||
}
|
||||
} else if (split->mode & MZ_OPEN_MODE_READ) {
|
||||
if (split->current_disk == 0) {
|
||||
err = mz_stream_read_uint32(split->stream.base, &magic);
|
||||
if (magic != MZ_ZIP_MAGIC_DISKHEADER)
|
||||
err = MZ_FORMAT_ERROR;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (err == MZ_OK) {
|
||||
/* Get the size of the current disk we are on */
|
||||
position = mz_stream_tell(split->stream.base);
|
||||
mz_stream_seek(split->stream.base, 0, MZ_SEEK_END);
|
||||
split->current_disk_size = mz_stream_tell(split->stream.base);
|
||||
mz_stream_seek(split->stream.base, position, MZ_SEEK_SET);
|
||||
|
||||
split->is_open = 1;
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static int32_t mz_stream_split_close_disk(void *stream) {
|
||||
mz_stream_split *split = (mz_stream_split *)stream;
|
||||
|
||||
if (mz_stream_is_open(split->stream.base) != MZ_OK)
|
||||
return MZ_OK;
|
||||
|
||||
mz_stream_split_print("Split - Close disk\n");
|
||||
return mz_stream_close(split->stream.base);
|
||||
}
|
||||
|
||||
static int32_t mz_stream_split_goto_disk(void *stream, int32_t number_disk) {
|
||||
mz_stream_split *split = (mz_stream_split *)stream;
|
||||
int32_t err = MZ_OK;
|
||||
int32_t err_is_open = MZ_OK;
|
||||
|
||||
err_is_open = mz_stream_is_open(split->stream.base);
|
||||
|
||||
if ((split->disk_size == 0) && (split->mode & MZ_OPEN_MODE_WRITE)) {
|
||||
if (err_is_open != MZ_OK)
|
||||
err = mz_stream_split_open_disk(stream, number_disk);
|
||||
} else if ((number_disk != split->current_disk) || (err_is_open != MZ_OK)) {
|
||||
err = mz_stream_split_close_disk(stream);
|
||||
if (err == MZ_OK) {
|
||||
err = mz_stream_split_open_disk(stream, number_disk);
|
||||
if (err == MZ_OK)
|
||||
split->number_disk = number_disk;
|
||||
}
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
int32_t mz_stream_split_open(void *stream, const char *path, int32_t mode) {
|
||||
mz_stream_split *split = (mz_stream_split *)stream;
|
||||
int32_t number_disk = 0;
|
||||
|
||||
split->mode = mode;
|
||||
|
||||
split->path_cd_size = (uint32_t)strlen(path) + 1;
|
||||
split->path_cd = (char *)MZ_ALLOC(split->path_cd_size);
|
||||
|
||||
if (split->path_cd == NULL)
|
||||
return MZ_MEM_ERROR;
|
||||
|
||||
strncpy(split->path_cd, path, split->path_cd_size - 1);
|
||||
split->path_cd[split->path_cd_size - 1] = 0;
|
||||
|
||||
mz_stream_split_print("Split - Open - %s (disk %" PRId32 ")\n", split->path_cd, number_disk);
|
||||
|
||||
split->path_disk_size = (uint32_t)strlen(path) + 10;
|
||||
split->path_disk = (char *)MZ_ALLOC(split->path_disk_size);
|
||||
|
||||
if (split->path_disk == NULL) {
|
||||
MZ_FREE(split->path_cd);
|
||||
return MZ_MEM_ERROR;
|
||||
}
|
||||
|
||||
strncpy(split->path_disk, path, split->path_disk_size - 1);
|
||||
split->path_disk[split->path_disk_size - 1] = 0;
|
||||
|
||||
if ((mode & MZ_OPEN_MODE_WRITE) && ((mode & MZ_OPEN_MODE_APPEND) == 0)) {
|
||||
number_disk = 0;
|
||||
split->current_disk = -1;
|
||||
} else {
|
||||
number_disk = -1;
|
||||
split->current_disk = 0;
|
||||
}
|
||||
|
||||
return mz_stream_split_goto_disk(stream, number_disk);
|
||||
}
|
||||
|
||||
int32_t mz_stream_split_is_open(void *stream) {
|
||||
mz_stream_split *split = (mz_stream_split *)stream;
|
||||
if (split->is_open != 1)
|
||||
return MZ_OPEN_ERROR;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_split_read(void *stream, void *buf, int32_t size) {
|
||||
mz_stream_split *split = (mz_stream_split *)stream;
|
||||
int32_t bytes_left = size;
|
||||
int32_t read = 0;
|
||||
int32_t err = MZ_OK;
|
||||
uint8_t *buf_ptr = (uint8_t *)buf;
|
||||
|
||||
err = mz_stream_split_goto_disk(stream, split->number_disk);
|
||||
if (err != MZ_OK)
|
||||
return err;
|
||||
|
||||
while (bytes_left > 0) {
|
||||
read = mz_stream_read(split->stream.base, buf_ptr, bytes_left);
|
||||
|
||||
mz_stream_split_print("Split - Read disk - %" PRId32 "\n", read);
|
||||
|
||||
if (read < 0)
|
||||
return read;
|
||||
if (read == 0) {
|
||||
if (split->current_disk < 0) /* No more disks to goto */
|
||||
break;
|
||||
err = mz_stream_split_goto_disk(stream, split->current_disk + 1);
|
||||
if (err == MZ_EXIST_ERROR) {
|
||||
split->current_disk = -1;
|
||||
break;
|
||||
}
|
||||
if (err != MZ_OK)
|
||||
return err;
|
||||
}
|
||||
|
||||
bytes_left -= read;
|
||||
buf_ptr += read;
|
||||
split->total_in += read;
|
||||
split->total_in_disk += read;
|
||||
}
|
||||
return size - bytes_left;
|
||||
}
|
||||
|
||||
int32_t mz_stream_split_write(void *stream, const void *buf, int32_t size) {
|
||||
mz_stream_split *split = (mz_stream_split *)stream;
|
||||
int64_t position = 0;
|
||||
int32_t written = 0;
|
||||
int32_t bytes_left = size;
|
||||
int32_t bytes_to_write = 0;
|
||||
int32_t bytes_avail = 0;
|
||||
int32_t number_disk = -1;
|
||||
int32_t err = MZ_OK;
|
||||
const uint8_t *buf_ptr = (const uint8_t *)buf;
|
||||
|
||||
position = mz_stream_tell(split->stream.base);
|
||||
|
||||
while (bytes_left > 0) {
|
||||
bytes_to_write = bytes_left;
|
||||
|
||||
if (split->disk_size > 0) {
|
||||
if ((split->total_out_disk == split->disk_size && split->total_out > 0) ||
|
||||
(split->number_disk == -1 && split->number_disk != split->current_disk)) {
|
||||
if (split->number_disk != -1)
|
||||
number_disk = split->current_disk + 1;
|
||||
|
||||
err = mz_stream_split_goto_disk(stream, number_disk);
|
||||
if (err != MZ_OK)
|
||||
return err;
|
||||
}
|
||||
|
||||
if (split->number_disk != -1) {
|
||||
bytes_avail = (int32_t)(split->disk_size - split->total_out_disk);
|
||||
if (bytes_to_write > bytes_avail)
|
||||
bytes_to_write = bytes_avail;
|
||||
}
|
||||
}
|
||||
|
||||
written = mz_stream_write(split->stream.base, buf_ptr, bytes_to_write);
|
||||
if (written != bytes_to_write)
|
||||
return MZ_WRITE_ERROR;
|
||||
|
||||
mz_stream_split_print("Split - Write disk - %" PRId32 "\n", written);
|
||||
|
||||
bytes_left -= written;
|
||||
buf_ptr += written;
|
||||
|
||||
split->total_out += written;
|
||||
split->total_out_disk += written;
|
||||
|
||||
if (position == split->current_disk_size) {
|
||||
split->current_disk_size += written;
|
||||
position = split->current_disk_size;
|
||||
}
|
||||
}
|
||||
|
||||
return size - bytes_left;
|
||||
}
|
||||
|
||||
int64_t mz_stream_split_tell(void *stream) {
|
||||
mz_stream_split *split = (mz_stream_split *)stream;
|
||||
int32_t err = MZ_OK;
|
||||
err = mz_stream_split_goto_disk(stream, split->number_disk);
|
||||
if (err != MZ_OK)
|
||||
return err;
|
||||
return mz_stream_tell(split->stream.base);
|
||||
}
|
||||
|
||||
int32_t mz_stream_split_seek(void *stream, int64_t offset, int32_t origin) {
|
||||
mz_stream_split *split = (mz_stream_split *)stream;
|
||||
int64_t disk_left = 0;
|
||||
int64_t position = 0;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
err = mz_stream_split_goto_disk(stream, split->number_disk);
|
||||
|
||||
if (err != MZ_OK)
|
||||
return err;
|
||||
|
||||
mz_stream_split_print("Split - Seek disk - %" PRId64 " (origin %" PRId32 ")\n", offset, origin);
|
||||
|
||||
if ((origin == MZ_SEEK_CUR) && (split->number_disk != -1)) {
|
||||
position = mz_stream_tell(split->stream.base);
|
||||
disk_left = split->current_disk_size - position;
|
||||
|
||||
while (offset > disk_left) {
|
||||
err = mz_stream_split_goto_disk(stream, split->current_disk + 1);
|
||||
if (err != MZ_OK)
|
||||
return err;
|
||||
|
||||
offset -= disk_left;
|
||||
disk_left = split->current_disk_size;
|
||||
}
|
||||
}
|
||||
|
||||
return mz_stream_seek(split->stream.base, offset, origin);
|
||||
}
|
||||
|
||||
int32_t mz_stream_split_close(void *stream) {
|
||||
mz_stream_split *split = (mz_stream_split *)stream;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
err = mz_stream_split_close_disk(stream);
|
||||
split->is_open = 0;
|
||||
return err;
|
||||
}
|
||||
|
||||
int32_t mz_stream_split_error(void *stream) {
|
||||
mz_stream_split *split = (mz_stream_split *)stream;
|
||||
return mz_stream_error(split->stream.base);
|
||||
}
|
||||
|
||||
int32_t mz_stream_split_get_prop_int64(void *stream, int32_t prop, int64_t *value) {
|
||||
mz_stream_split *split = (mz_stream_split *)stream;
|
||||
switch (prop) {
|
||||
case MZ_STREAM_PROP_TOTAL_OUT:
|
||||
*value = split->total_out;
|
||||
break;
|
||||
case MZ_STREAM_PROP_DISK_NUMBER:
|
||||
*value = split->number_disk;
|
||||
break;
|
||||
case MZ_STREAM_PROP_DISK_SIZE:
|
||||
*value = split->disk_size;
|
||||
break;
|
||||
default:
|
||||
return MZ_EXIST_ERROR;
|
||||
}
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_split_set_prop_int64(void *stream, int32_t prop, int64_t value) {
|
||||
mz_stream_split *split = (mz_stream_split *)stream;
|
||||
switch (prop) {
|
||||
case MZ_STREAM_PROP_DISK_NUMBER:
|
||||
split->number_disk = (int32_t)value;
|
||||
break;
|
||||
case MZ_STREAM_PROP_DISK_SIZE:
|
||||
split->disk_size = value;
|
||||
break;
|
||||
default:
|
||||
return MZ_EXIST_ERROR;
|
||||
}
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
void *mz_stream_split_create(void **stream) {
|
||||
mz_stream_split *split = NULL;
|
||||
|
||||
split = (mz_stream_split *)MZ_ALLOC(sizeof(mz_stream_split));
|
||||
if (split != NULL) {
|
||||
memset(split, 0, sizeof(mz_stream_split));
|
||||
split->stream.vtbl = &mz_stream_split_vtbl;
|
||||
}
|
||||
if (stream != NULL)
|
||||
*stream = split;
|
||||
|
||||
return split;
|
||||
}
|
||||
|
||||
void mz_stream_split_delete(void **stream) {
|
||||
mz_stream_split *split = NULL;
|
||||
if (stream == NULL)
|
||||
return;
|
||||
split = (mz_stream_split *)*stream;
|
||||
if (split != NULL) {
|
||||
if (split->path_cd)
|
||||
MZ_FREE(split->path_cd);
|
||||
if (split->path_disk)
|
||||
MZ_FREE(split->path_disk);
|
||||
|
||||
MZ_FREE(split);
|
||||
}
|
||||
*stream = NULL;
|
||||
}
|
||||
|
||||
void *mz_stream_split_get_interface(void) {
|
||||
return (void *)&mz_stream_split_vtbl;
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
/* mz_strm_split.h -- Stream for split files
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
#ifndef MZ_STREAM_SPLIT_H
|
||||
#define MZ_STREAM_SPLIT_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_stream_split_open(void *stream, const char *filename, int32_t mode);
|
||||
int32_t mz_stream_split_is_open(void *stream);
|
||||
int32_t mz_stream_split_read(void *stream, void *buf, int32_t size);
|
||||
int32_t mz_stream_split_write(void *stream, const void *buf, int32_t size);
|
||||
int64_t mz_stream_split_tell(void *stream);
|
||||
int32_t mz_stream_split_seek(void *stream, int64_t offset, int32_t origin);
|
||||
int32_t mz_stream_split_close(void *stream);
|
||||
int32_t mz_stream_split_error(void *stream);
|
||||
|
||||
int32_t mz_stream_split_get_prop_int64(void *stream, int32_t prop, int64_t *value);
|
||||
int32_t mz_stream_split_set_prop_int64(void *stream, int32_t prop, int64_t value);
|
||||
|
||||
void* mz_stream_split_create(void **stream);
|
||||
void mz_stream_split_delete(void **stream);
|
||||
|
||||
void* mz_stream_split_get_interface(void);
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,362 @@
|
|||
/* mz_strm_wzaes.c -- Stream for WinZip AES encryption
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
Copyright (C) 1998-2010 Brian Gladman, Worcester, UK
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
|
||||
#include "mz.h"
|
||||
#include "mz_crypt.h"
|
||||
#include "mz_strm.h"
|
||||
#include "mz_strm_wzaes.h"
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#define MZ_AES_KEYING_ITERATIONS (1000)
|
||||
#define MZ_AES_SALT_LENGTH(MODE) (4 * (MODE & 3) + 4)
|
||||
#define MZ_AES_SALT_LENGTH_MAX (16)
|
||||
#define MZ_AES_PW_LENGTH_MAX (128)
|
||||
#define MZ_AES_PW_VERIFY_SIZE (2)
|
||||
#define MZ_AES_AUTHCODE_SIZE (10)
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
static mz_stream_vtbl mz_stream_wzaes_vtbl = {
|
||||
mz_stream_wzaes_open,
|
||||
mz_stream_wzaes_is_open,
|
||||
mz_stream_wzaes_read,
|
||||
mz_stream_wzaes_write,
|
||||
mz_stream_wzaes_tell,
|
||||
mz_stream_wzaes_seek,
|
||||
mz_stream_wzaes_close,
|
||||
mz_stream_wzaes_error,
|
||||
mz_stream_wzaes_create,
|
||||
mz_stream_wzaes_delete,
|
||||
mz_stream_wzaes_get_prop_int64,
|
||||
mz_stream_wzaes_set_prop_int64
|
||||
};
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
typedef struct mz_stream_wzaes_s {
|
||||
mz_stream stream;
|
||||
int32_t mode;
|
||||
int32_t error;
|
||||
int16_t initialized;
|
||||
uint8_t buffer[UINT16_MAX];
|
||||
int64_t total_in;
|
||||
int64_t max_total_in;
|
||||
int64_t total_out;
|
||||
int16_t encryption_mode;
|
||||
const char *password;
|
||||
void *aes;
|
||||
uint32_t crypt_pos;
|
||||
uint8_t crypt_block[MZ_AES_BLOCK_SIZE];
|
||||
void *hmac;
|
||||
uint8_t nonce[MZ_AES_BLOCK_SIZE];
|
||||
} mz_stream_wzaes;
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_stream_wzaes_open(void *stream, const char *path, int32_t mode) {
|
||||
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
|
||||
uint16_t salt_length = 0;
|
||||
uint16_t password_length = 0;
|
||||
uint16_t key_length = 0;
|
||||
uint8_t kbuf[2 * MZ_AES_KEY_LENGTH_MAX + MZ_AES_PW_VERIFY_SIZE];
|
||||
uint8_t verify[MZ_AES_PW_VERIFY_SIZE];
|
||||
uint8_t verify_expected[MZ_AES_PW_VERIFY_SIZE];
|
||||
uint8_t salt_value[MZ_AES_SALT_LENGTH_MAX];
|
||||
const char *password = path;
|
||||
|
||||
wzaes->total_in = 0;
|
||||
wzaes->total_out = 0;
|
||||
wzaes->initialized = 0;
|
||||
|
||||
if (mz_stream_is_open(wzaes->stream.base) != MZ_OK)
|
||||
return MZ_OPEN_ERROR;
|
||||
|
||||
if (password == NULL)
|
||||
password = wzaes->password;
|
||||
if (password == NULL)
|
||||
return MZ_PARAM_ERROR;
|
||||
password_length = (uint16_t)strlen(password);
|
||||
if (password_length > MZ_AES_PW_LENGTH_MAX)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
if (wzaes->encryption_mode < 1 || wzaes->encryption_mode > 3)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
salt_length = MZ_AES_SALT_LENGTH(wzaes->encryption_mode);
|
||||
|
||||
if (mode & MZ_OPEN_MODE_WRITE) {
|
||||
mz_crypt_rand(salt_value, salt_length);
|
||||
} else if (mode & MZ_OPEN_MODE_READ) {
|
||||
if (mz_stream_read(wzaes->stream.base, salt_value, salt_length) != salt_length)
|
||||
return MZ_READ_ERROR;
|
||||
}
|
||||
|
||||
key_length = MZ_AES_KEY_LENGTH(wzaes->encryption_mode);
|
||||
|
||||
/* Derive the encryption and authentication keys and the password verifier */
|
||||
mz_crypt_pbkdf2((uint8_t *)password, password_length, salt_value, salt_length,
|
||||
MZ_AES_KEYING_ITERATIONS, kbuf, 2 * key_length + MZ_AES_PW_VERIFY_SIZE);
|
||||
|
||||
/* Initialize the encryption nonce and buffer pos */
|
||||
wzaes->crypt_pos = MZ_AES_BLOCK_SIZE;
|
||||
memset(wzaes->nonce, 0, sizeof(wzaes->nonce));
|
||||
|
||||
/* Initialize for encryption using key 1 */
|
||||
mz_crypt_aes_reset(wzaes->aes);
|
||||
mz_crypt_aes_set_mode(wzaes->aes, wzaes->encryption_mode);
|
||||
mz_crypt_aes_set_encrypt_key(wzaes->aes, kbuf, key_length);
|
||||
|
||||
/* Initialize for authentication using key 2 */
|
||||
mz_crypt_hmac_reset(wzaes->hmac);
|
||||
mz_crypt_hmac_set_algorithm(wzaes->hmac, MZ_HASH_SHA1);
|
||||
mz_crypt_hmac_init(wzaes->hmac, kbuf + key_length, key_length);
|
||||
|
||||
memcpy(verify, kbuf + (2 * key_length), MZ_AES_PW_VERIFY_SIZE);
|
||||
|
||||
if (mode & MZ_OPEN_MODE_WRITE) {
|
||||
if (mz_stream_write(wzaes->stream.base, salt_value, salt_length) != salt_length)
|
||||
return MZ_WRITE_ERROR;
|
||||
|
||||
wzaes->total_out += salt_length;
|
||||
|
||||
if (mz_stream_write(wzaes->stream.base, verify, MZ_AES_PW_VERIFY_SIZE) != MZ_AES_PW_VERIFY_SIZE)
|
||||
return MZ_WRITE_ERROR;
|
||||
|
||||
wzaes->total_out += MZ_AES_PW_VERIFY_SIZE;
|
||||
} else if (mode & MZ_OPEN_MODE_READ) {
|
||||
wzaes->total_in += salt_length;
|
||||
|
||||
if (mz_stream_read(wzaes->stream.base, verify_expected, MZ_AES_PW_VERIFY_SIZE) != MZ_AES_PW_VERIFY_SIZE)
|
||||
return MZ_READ_ERROR;
|
||||
|
||||
wzaes->total_in += MZ_AES_PW_VERIFY_SIZE;
|
||||
|
||||
if (memcmp(verify_expected, verify, MZ_AES_PW_VERIFY_SIZE) != 0)
|
||||
return MZ_PASSWORD_ERROR;
|
||||
}
|
||||
|
||||
wzaes->mode = mode;
|
||||
wzaes->initialized = 1;
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_wzaes_is_open(void *stream) {
|
||||
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
|
||||
if (wzaes->initialized == 0)
|
||||
return MZ_OPEN_ERROR;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
static int32_t mz_stream_wzaes_ctr_encrypt(void *stream, uint8_t *buf, int32_t size) {
|
||||
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
|
||||
uint32_t pos = wzaes->crypt_pos;
|
||||
uint32_t i = 0;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
while (i < (uint32_t)size) {
|
||||
if (pos == MZ_AES_BLOCK_SIZE) {
|
||||
uint32_t j = 0;
|
||||
|
||||
/* Increment encryption nonce */
|
||||
while (j < 8 && !++wzaes->nonce[j])
|
||||
j += 1;
|
||||
|
||||
/* Encrypt the nonce to form next xor buffer */
|
||||
memcpy(wzaes->crypt_block, wzaes->nonce, MZ_AES_BLOCK_SIZE);
|
||||
mz_crypt_aes_encrypt(wzaes->aes, wzaes->crypt_block, sizeof(wzaes->crypt_block));
|
||||
pos = 0;
|
||||
}
|
||||
|
||||
buf[i++] ^= wzaes->crypt_block[pos++];
|
||||
}
|
||||
|
||||
wzaes->crypt_pos = pos;
|
||||
return err;
|
||||
}
|
||||
|
||||
int32_t mz_stream_wzaes_read(void *stream, void *buf, int32_t size) {
|
||||
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
|
||||
int64_t max_total_in = 0;
|
||||
int32_t bytes_to_read = size;
|
||||
int32_t read = 0;
|
||||
|
||||
max_total_in = wzaes->max_total_in - MZ_AES_FOOTER_SIZE;
|
||||
if ((int64_t)bytes_to_read > (max_total_in - wzaes->total_in))
|
||||
bytes_to_read = (int32_t)(max_total_in - wzaes->total_in);
|
||||
|
||||
read = mz_stream_read(wzaes->stream.base, buf, bytes_to_read);
|
||||
|
||||
if (read > 0) {
|
||||
mz_crypt_hmac_update(wzaes->hmac, (uint8_t *)buf, read);
|
||||
mz_stream_wzaes_ctr_encrypt(stream, (uint8_t *)buf, read);
|
||||
|
||||
wzaes->total_in += read;
|
||||
}
|
||||
|
||||
return read;
|
||||
}
|
||||
|
||||
int32_t mz_stream_wzaes_write(void *stream, const void *buf, int32_t size) {
|
||||
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
|
||||
const uint8_t *buf_ptr = (const uint8_t *)buf;
|
||||
int32_t bytes_to_write = sizeof(wzaes->buffer);
|
||||
int32_t total_written = 0;
|
||||
int32_t written = 0;
|
||||
|
||||
if (size < 0)
|
||||
return MZ_PARAM_ERROR;
|
||||
|
||||
do {
|
||||
if (bytes_to_write > (size - total_written))
|
||||
bytes_to_write = (size - total_written);
|
||||
|
||||
memcpy(wzaes->buffer, buf_ptr, bytes_to_write);
|
||||
buf_ptr += bytes_to_write;
|
||||
|
||||
mz_stream_wzaes_ctr_encrypt(stream, (uint8_t *)wzaes->buffer, bytes_to_write);
|
||||
mz_crypt_hmac_update(wzaes->hmac, wzaes->buffer, bytes_to_write);
|
||||
|
||||
written = mz_stream_write(wzaes->stream.base, wzaes->buffer, bytes_to_write);
|
||||
if (written < 0)
|
||||
return written;
|
||||
|
||||
total_written += written;
|
||||
} while (total_written < size && written > 0);
|
||||
|
||||
wzaes->total_out += total_written;
|
||||
return total_written;
|
||||
}
|
||||
|
||||
int64_t mz_stream_wzaes_tell(void *stream) {
|
||||
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
|
||||
return mz_stream_tell(wzaes->stream.base);
|
||||
}
|
||||
|
||||
int32_t mz_stream_wzaes_seek(void *stream, int64_t offset, int32_t origin) {
|
||||
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
|
||||
return mz_stream_seek(wzaes->stream.base, offset, origin);
|
||||
}
|
||||
|
||||
int32_t mz_stream_wzaes_close(void *stream) {
|
||||
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
|
||||
uint8_t expected_hash[MZ_AES_AUTHCODE_SIZE];
|
||||
uint8_t computed_hash[MZ_HASH_SHA1_SIZE];
|
||||
|
||||
mz_crypt_hmac_end(wzaes->hmac, computed_hash, sizeof(computed_hash));
|
||||
|
||||
if (wzaes->mode & MZ_OPEN_MODE_WRITE) {
|
||||
if (mz_stream_write(wzaes->stream.base, computed_hash, MZ_AES_AUTHCODE_SIZE) != MZ_AES_AUTHCODE_SIZE)
|
||||
return MZ_WRITE_ERROR;
|
||||
|
||||
wzaes->total_out += MZ_AES_AUTHCODE_SIZE;
|
||||
} else if (wzaes->mode & MZ_OPEN_MODE_READ) {
|
||||
if (mz_stream_read(wzaes->stream.base, expected_hash, MZ_AES_AUTHCODE_SIZE) != MZ_AES_AUTHCODE_SIZE)
|
||||
return MZ_READ_ERROR;
|
||||
|
||||
wzaes->total_in += MZ_AES_AUTHCODE_SIZE;
|
||||
|
||||
/* If entire entry was not read this will fail */
|
||||
if (memcmp(computed_hash, expected_hash, MZ_AES_AUTHCODE_SIZE) != 0)
|
||||
return MZ_CRC_ERROR;
|
||||
}
|
||||
|
||||
wzaes->initialized = 0;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_wzaes_error(void *stream) {
|
||||
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
|
||||
return wzaes->error;
|
||||
}
|
||||
|
||||
void mz_stream_wzaes_set_password(void *stream, const char *password) {
|
||||
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
|
||||
wzaes->password = password;
|
||||
}
|
||||
|
||||
void mz_stream_wzaes_set_encryption_mode(void *stream, int16_t encryption_mode) {
|
||||
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
|
||||
wzaes->encryption_mode = encryption_mode;
|
||||
}
|
||||
|
||||
int32_t mz_stream_wzaes_get_prop_int64(void *stream, int32_t prop, int64_t *value) {
|
||||
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
|
||||
switch (prop) {
|
||||
case MZ_STREAM_PROP_TOTAL_IN:
|
||||
*value = wzaes->total_in;
|
||||
break;
|
||||
case MZ_STREAM_PROP_TOTAL_OUT:
|
||||
*value = wzaes->total_out;
|
||||
break;
|
||||
case MZ_STREAM_PROP_TOTAL_IN_MAX:
|
||||
*value = wzaes->max_total_in;
|
||||
break;
|
||||
case MZ_STREAM_PROP_HEADER_SIZE:
|
||||
*value = MZ_AES_SALT_LENGTH((int64_t)wzaes->encryption_mode) + MZ_AES_PW_VERIFY_SIZE;
|
||||
break;
|
||||
case MZ_STREAM_PROP_FOOTER_SIZE:
|
||||
*value = MZ_AES_AUTHCODE_SIZE;
|
||||
break;
|
||||
default:
|
||||
return MZ_EXIST_ERROR;
|
||||
}
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_wzaes_set_prop_int64(void *stream, int32_t prop, int64_t value) {
|
||||
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
|
||||
switch (prop) {
|
||||
case MZ_STREAM_PROP_TOTAL_IN_MAX:
|
||||
wzaes->max_total_in = value;
|
||||
break;
|
||||
default:
|
||||
return MZ_EXIST_ERROR;
|
||||
}
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
void *mz_stream_wzaes_create(void **stream) {
|
||||
mz_stream_wzaes *wzaes = NULL;
|
||||
|
||||
wzaes = (mz_stream_wzaes *)MZ_ALLOC(sizeof(mz_stream_wzaes));
|
||||
if (wzaes != NULL) {
|
||||
memset(wzaes, 0, sizeof(mz_stream_wzaes));
|
||||
wzaes->stream.vtbl = &mz_stream_wzaes_vtbl;
|
||||
wzaes->encryption_mode = MZ_AES_ENCRYPTION_MODE_256;
|
||||
|
||||
mz_crypt_hmac_create(&wzaes->hmac);
|
||||
mz_crypt_aes_create(&wzaes->aes);
|
||||
}
|
||||
if (stream != NULL)
|
||||
*stream = wzaes;
|
||||
|
||||
return wzaes;
|
||||
}
|
||||
|
||||
void mz_stream_wzaes_delete(void **stream) {
|
||||
mz_stream_wzaes *wzaes = NULL;
|
||||
if (stream == NULL)
|
||||
return;
|
||||
wzaes = (mz_stream_wzaes *)*stream;
|
||||
if (wzaes != NULL) {
|
||||
mz_crypt_aes_delete(&wzaes->aes);
|
||||
mz_crypt_hmac_delete(&wzaes->hmac);
|
||||
MZ_FREE(wzaes);
|
||||
}
|
||||
*stream = NULL;
|
||||
}
|
||||
|
||||
void *mz_stream_wzaes_get_interface(void) {
|
||||
return (void *)&mz_stream_wzaes_vtbl;
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
/* mz_strm_wzaes.h -- Stream for WinZIP AES encryption
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
#ifndef MZ_STREAM_WZAES_SHA1_H
|
||||
#define MZ_STREAM_WZAES_SHA1_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_stream_wzaes_open(void *stream, const char *filename, int32_t mode);
|
||||
int32_t mz_stream_wzaes_is_open(void *stream);
|
||||
int32_t mz_stream_wzaes_read(void *stream, void *buf, int32_t size);
|
||||
int32_t mz_stream_wzaes_write(void *stream, const void *buf, int32_t size);
|
||||
int64_t mz_stream_wzaes_tell(void *stream);
|
||||
int32_t mz_stream_wzaes_seek(void *stream, int64_t offset, int32_t origin);
|
||||
int32_t mz_stream_wzaes_close(void *stream);
|
||||
int32_t mz_stream_wzaes_error(void *stream);
|
||||
|
||||
void mz_stream_wzaes_set_password(void *stream, const char *password);
|
||||
void mz_stream_wzaes_set_encryption_mode(void *stream, int16_t encryption_mode);
|
||||
|
||||
int32_t mz_stream_wzaes_get_prop_int64(void *stream, int32_t prop, int64_t *value);
|
||||
int32_t mz_stream_wzaes_set_prop_int64(void *stream, int32_t prop, int64_t value);
|
||||
|
||||
void* mz_stream_wzaes_create(void **stream);
|
||||
void mz_stream_wzaes_delete(void **stream);
|
||||
|
||||
void* mz_stream_wzaes_get_interface(void);
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,393 @@
|
|||
/* mz_strm_zlib.c -- Stream for zlib inflate/deflate
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
|
||||
#include "mz.h"
|
||||
#include "mz_strm.h"
|
||||
#include "mz_strm_zlib.h"
|
||||
|
||||
#include "zlib.h"
|
||||
#if defined(ZLIBNG_VERNUM) && !defined(ZLIB_COMPAT)
|
||||
# include "zlib-ng.h"
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#if defined(ZLIBNG_VERNUM) && !defined(ZLIB_COMPAT)
|
||||
# define ZLIB_PREFIX(x) zng_ ## x
|
||||
typedef zng_stream zlib_stream;
|
||||
#else
|
||||
# define ZLIB_PREFIX(x) x
|
||||
typedef z_stream zlib_stream;
|
||||
#endif
|
||||
|
||||
#if !defined(DEF_MEM_LEVEL)
|
||||
# if MAX_MEM_LEVEL >= 8
|
||||
# define DEF_MEM_LEVEL 8
|
||||
# else
|
||||
# define DEF_MEM_LEVEL MAX_MEM_LEVEL
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
static mz_stream_vtbl mz_stream_zlib_vtbl = {
|
||||
mz_stream_zlib_open,
|
||||
mz_stream_zlib_is_open,
|
||||
mz_stream_zlib_read,
|
||||
mz_stream_zlib_write,
|
||||
mz_stream_zlib_tell,
|
||||
mz_stream_zlib_seek,
|
||||
mz_stream_zlib_close,
|
||||
mz_stream_zlib_error,
|
||||
mz_stream_zlib_create,
|
||||
mz_stream_zlib_delete,
|
||||
mz_stream_zlib_get_prop_int64,
|
||||
mz_stream_zlib_set_prop_int64
|
||||
};
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
typedef struct mz_stream_zlib_s {
|
||||
mz_stream stream;
|
||||
zlib_stream zstream;
|
||||
uint8_t buffer[INT16_MAX];
|
||||
int32_t buffer_len;
|
||||
int64_t total_in;
|
||||
int64_t total_out;
|
||||
int64_t max_total_in;
|
||||
int8_t initialized;
|
||||
int16_t level;
|
||||
int32_t window_bits;
|
||||
int32_t mode;
|
||||
int32_t error;
|
||||
} mz_stream_zlib;
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_stream_zlib_open(void *stream, const char *path, int32_t mode) {
|
||||
mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
|
||||
|
||||
MZ_UNUSED(path);
|
||||
|
||||
zlib->zstream.data_type = Z_BINARY;
|
||||
zlib->zstream.zalloc = Z_NULL;
|
||||
zlib->zstream.zfree = Z_NULL;
|
||||
zlib->zstream.opaque = Z_NULL;
|
||||
zlib->zstream.total_in = 0;
|
||||
zlib->zstream.total_out = 0;
|
||||
|
||||
zlib->total_in = 0;
|
||||
zlib->total_out = 0;
|
||||
|
||||
if (mode & MZ_OPEN_MODE_WRITE) {
|
||||
#ifdef MZ_ZIP_NO_COMPRESSION
|
||||
return MZ_SUPPORT_ERROR;
|
||||
#else
|
||||
zlib->zstream.next_out = zlib->buffer;
|
||||
zlib->zstream.avail_out = sizeof(zlib->buffer);
|
||||
|
||||
zlib->error = ZLIB_PREFIX(deflateInit2)(&zlib->zstream, (int8_t)zlib->level, Z_DEFLATED,
|
||||
zlib->window_bits, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
|
||||
#endif
|
||||
} else if (mode & MZ_OPEN_MODE_READ) {
|
||||
#ifdef MZ_ZIP_NO_DECOMPRESSION
|
||||
return MZ_SUPPORT_ERROR;
|
||||
#else
|
||||
zlib->zstream.next_in = zlib->buffer;
|
||||
zlib->zstream.avail_in = 0;
|
||||
|
||||
zlib->error = ZLIB_PREFIX(inflateInit2)(&zlib->zstream, zlib->window_bits);
|
||||
#endif
|
||||
}
|
||||
|
||||
if (zlib->error != Z_OK)
|
||||
return MZ_OPEN_ERROR;
|
||||
|
||||
zlib->initialized = 1;
|
||||
zlib->mode = mode;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_zlib_is_open(void *stream) {
|
||||
mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
|
||||
if (zlib->initialized != 1)
|
||||
return MZ_OPEN_ERROR;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_zlib_read(void *stream, void *buf, int32_t size) {
|
||||
#ifdef MZ_ZIP_NO_DECOMPRESSION
|
||||
MZ_UNUSED(stream);
|
||||
MZ_UNUSED(buf);
|
||||
MZ_UNUSED(size);
|
||||
return MZ_SUPPORT_ERROR;
|
||||
#else
|
||||
mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
|
||||
uint64_t total_in_before = 0;
|
||||
uint64_t total_in_after = 0;
|
||||
uint64_t total_out_before = 0;
|
||||
uint64_t total_out_after = 0;
|
||||
//uint32_t total_in = 0;
|
||||
uint32_t total_out = 0;
|
||||
uint32_t in_bytes = 0;
|
||||
uint32_t out_bytes = 0;
|
||||
int32_t bytes_to_read = sizeof(zlib->buffer);
|
||||
int32_t read = 0;
|
||||
int32_t err = Z_OK;
|
||||
|
||||
|
||||
zlib->zstream.next_out = (Bytef*)buf;
|
||||
zlib->zstream.avail_out = (uInt)size;
|
||||
|
||||
do {
|
||||
if (zlib->zstream.avail_in == 0) {
|
||||
if (zlib->max_total_in > 0) {
|
||||
if ((int64_t)bytes_to_read > (zlib->max_total_in - zlib->total_in))
|
||||
bytes_to_read = (int32_t)(zlib->max_total_in - zlib->total_in);
|
||||
}
|
||||
|
||||
read = mz_stream_read(zlib->stream.base, zlib->buffer, bytes_to_read);
|
||||
|
||||
if (read < 0)
|
||||
return read;
|
||||
|
||||
zlib->zstream.next_in = zlib->buffer;
|
||||
zlib->zstream.avail_in = read;
|
||||
}
|
||||
|
||||
total_in_before = zlib->zstream.avail_in;
|
||||
total_out_before = zlib->zstream.total_out;
|
||||
|
||||
err = ZLIB_PREFIX(inflate)(&zlib->zstream, Z_SYNC_FLUSH);
|
||||
if ((err >= Z_OK) && (zlib->zstream.msg != NULL)) {
|
||||
zlib->error = Z_DATA_ERROR;
|
||||
break;
|
||||
}
|
||||
|
||||
total_in_after = zlib->zstream.avail_in;
|
||||
total_out_after = zlib->zstream.total_out;
|
||||
|
||||
in_bytes = (uint32_t)(total_in_before - total_in_after);
|
||||
out_bytes = (uint32_t)(total_out_after - total_out_before);
|
||||
|
||||
//total_in += in_bytes;
|
||||
total_out += out_bytes;
|
||||
|
||||
zlib->total_in += in_bytes;
|
||||
zlib->total_out += out_bytes;
|
||||
|
||||
if (err == Z_STREAM_END)
|
||||
break;
|
||||
if (err != Z_OK) {
|
||||
zlib->error = err;
|
||||
break;
|
||||
}
|
||||
} while (zlib->zstream.avail_out > 0);
|
||||
|
||||
if (zlib->error != 0) {
|
||||
/* Zlib errors are compatible with MZ */
|
||||
return zlib->error;
|
||||
}
|
||||
|
||||
return total_out;
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifndef MZ_ZIP_NO_COMPRESSION
|
||||
static int32_t mz_stream_zlib_flush(void *stream) {
|
||||
mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
|
||||
if (mz_stream_write(zlib->stream.base, zlib->buffer, zlib->buffer_len) != zlib->buffer_len)
|
||||
return MZ_WRITE_ERROR;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
static int32_t mz_stream_zlib_deflate(void *stream, int flush) {
|
||||
mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
|
||||
uint64_t total_out_before = 0;
|
||||
uint64_t total_out_after = 0;
|
||||
int32_t out_bytes = 0;
|
||||
int32_t err = Z_OK;
|
||||
|
||||
|
||||
do {
|
||||
if (zlib->zstream.avail_out == 0) {
|
||||
err = mz_stream_zlib_flush(zlib);
|
||||
if (err != MZ_OK)
|
||||
return err;
|
||||
|
||||
zlib->zstream.avail_out = sizeof(zlib->buffer);
|
||||
zlib->zstream.next_out = zlib->buffer;
|
||||
|
||||
zlib->buffer_len = 0;
|
||||
}
|
||||
|
||||
total_out_before = zlib->zstream.total_out;
|
||||
err = ZLIB_PREFIX(deflate)(&zlib->zstream, flush);
|
||||
total_out_after = zlib->zstream.total_out;
|
||||
|
||||
out_bytes = (uint32_t)(total_out_after - total_out_before);
|
||||
|
||||
zlib->buffer_len += out_bytes;
|
||||
zlib->total_out += out_bytes;
|
||||
|
||||
if (err == Z_STREAM_END)
|
||||
break;
|
||||
if (err != Z_OK) {
|
||||
zlib->error = err;
|
||||
return MZ_DATA_ERROR;
|
||||
}
|
||||
} while ((zlib->zstream.avail_in > 0) || (flush == Z_FINISH && err == Z_OK));
|
||||
|
||||
return MZ_OK;
|
||||
}
|
||||
#endif
|
||||
|
||||
int32_t mz_stream_zlib_write(void *stream, const void *buf, int32_t size) {
|
||||
#ifdef MZ_ZIP_NO_COMPRESSION
|
||||
MZ_UNUSED(stream);
|
||||
MZ_UNUSED(buf);
|
||||
MZ_UNUSED(size);
|
||||
return MZ_SUPPORT_ERROR;
|
||||
#else
|
||||
mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
|
||||
int32_t err = MZ_OK;
|
||||
|
||||
zlib->zstream.next_in = (Bytef*)(intptr_t)buf;
|
||||
zlib->zstream.avail_in = (uInt)size;
|
||||
|
||||
err = mz_stream_zlib_deflate(stream, Z_NO_FLUSH);
|
||||
if (err != MZ_OK) {
|
||||
return err;
|
||||
}
|
||||
|
||||
zlib->total_in += size;
|
||||
return size;
|
||||
#endif
|
||||
}
|
||||
|
||||
int64_t mz_stream_zlib_tell(void *stream) {
|
||||
MZ_UNUSED(stream);
|
||||
|
||||
return MZ_TELL_ERROR;
|
||||
}
|
||||
|
||||
int32_t mz_stream_zlib_seek(void *stream, int64_t offset, int32_t origin) {
|
||||
MZ_UNUSED(stream);
|
||||
MZ_UNUSED(offset);
|
||||
MZ_UNUSED(origin);
|
||||
|
||||
return MZ_SEEK_ERROR;
|
||||
}
|
||||
|
||||
int32_t mz_stream_zlib_close(void *stream) {
|
||||
mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
|
||||
|
||||
|
||||
if (zlib->mode & MZ_OPEN_MODE_WRITE) {
|
||||
#ifdef MZ_ZIP_NO_COMPRESSION
|
||||
return MZ_SUPPORT_ERROR;
|
||||
#else
|
||||
mz_stream_zlib_deflate(stream, Z_FINISH);
|
||||
mz_stream_zlib_flush(stream);
|
||||
|
||||
ZLIB_PREFIX(deflateEnd)(&zlib->zstream);
|
||||
#endif
|
||||
} else if (zlib->mode & MZ_OPEN_MODE_READ) {
|
||||
#ifdef MZ_ZIP_NO_DECOMPRESSION
|
||||
return MZ_SUPPORT_ERROR;
|
||||
#else
|
||||
ZLIB_PREFIX(inflateEnd)(&zlib->zstream);
|
||||
#endif
|
||||
}
|
||||
|
||||
zlib->initialized = 0;
|
||||
|
||||
if (zlib->error != Z_OK)
|
||||
return MZ_CLOSE_ERROR;
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_zlib_error(void *stream) {
|
||||
mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
|
||||
return zlib->error;
|
||||
}
|
||||
|
||||
int32_t mz_stream_zlib_get_prop_int64(void *stream, int32_t prop, int64_t *value) {
|
||||
mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
|
||||
switch (prop) {
|
||||
case MZ_STREAM_PROP_TOTAL_IN:
|
||||
*value = zlib->total_in;
|
||||
break;
|
||||
case MZ_STREAM_PROP_TOTAL_IN_MAX:
|
||||
*value = zlib->max_total_in;
|
||||
break;
|
||||
case MZ_STREAM_PROP_TOTAL_OUT:
|
||||
*value = zlib->total_out;
|
||||
break;
|
||||
case MZ_STREAM_PROP_HEADER_SIZE:
|
||||
*value = 0;
|
||||
break;
|
||||
case MZ_STREAM_PROP_COMPRESS_WINDOW:
|
||||
*value = zlib->window_bits;
|
||||
break;
|
||||
default:
|
||||
return MZ_EXIST_ERROR;
|
||||
}
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
int32_t mz_stream_zlib_set_prop_int64(void *stream, int32_t prop, int64_t value) {
|
||||
mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
|
||||
switch (prop) {
|
||||
case MZ_STREAM_PROP_COMPRESS_LEVEL:
|
||||
zlib->level = (int16_t)value;
|
||||
break;
|
||||
case MZ_STREAM_PROP_TOTAL_IN_MAX:
|
||||
zlib->max_total_in = value;
|
||||
break;
|
||||
case MZ_STREAM_PROP_COMPRESS_WINDOW:
|
||||
zlib->window_bits = (int32_t)value;
|
||||
break;
|
||||
default:
|
||||
return MZ_EXIST_ERROR;
|
||||
}
|
||||
return MZ_OK;
|
||||
}
|
||||
|
||||
void *mz_stream_zlib_create(void **stream) {
|
||||
mz_stream_zlib *zlib = NULL;
|
||||
|
||||
zlib = (mz_stream_zlib *)MZ_ALLOC(sizeof(mz_stream_zlib));
|
||||
if (zlib != NULL) {
|
||||
memset(zlib, 0, sizeof(mz_stream_zlib));
|
||||
zlib->stream.vtbl = &mz_stream_zlib_vtbl;
|
||||
zlib->level = Z_DEFAULT_COMPRESSION;
|
||||
zlib->window_bits = -MAX_WBITS;
|
||||
}
|
||||
if (stream != NULL)
|
||||
*stream = zlib;
|
||||
|
||||
return zlib;
|
||||
}
|
||||
|
||||
void mz_stream_zlib_delete(void **stream) {
|
||||
mz_stream_zlib *zlib = NULL;
|
||||
if (stream == NULL)
|
||||
return;
|
||||
zlib = (mz_stream_zlib *)*stream;
|
||||
if (zlib != NULL)
|
||||
MZ_FREE(zlib);
|
||||
*stream = NULL;
|
||||
}
|
||||
|
||||
void *mz_stream_zlib_get_interface(void) {
|
||||
return (void *)&mz_stream_zlib_vtbl;
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
/* mz_strm_zlib.h -- Stream for zlib inflate/deflate
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
#ifndef MZ_STREAM_ZLIB_H
|
||||
#define MZ_STREAM_ZLIB_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_stream_zlib_open(void *stream, const char *filename, int32_t mode);
|
||||
int32_t mz_stream_zlib_is_open(void *stream);
|
||||
int32_t mz_stream_zlib_read(void *stream, void *buf, int32_t size);
|
||||
int32_t mz_stream_zlib_write(void *stream, const void *buf, int32_t size);
|
||||
int64_t mz_stream_zlib_tell(void *stream);
|
||||
int32_t mz_stream_zlib_seek(void *stream, int64_t offset, int32_t origin);
|
||||
int32_t mz_stream_zlib_close(void *stream);
|
||||
int32_t mz_stream_zlib_error(void *stream);
|
||||
|
||||
int32_t mz_stream_zlib_get_prop_int64(void *stream, int32_t prop, int64_t *value);
|
||||
int32_t mz_stream_zlib_set_prop_int64(void *stream, int32_t prop, int64_t value);
|
||||
|
||||
void* mz_stream_zlib_create(void **stream);
|
||||
void mz_stream_zlib_delete(void **stream);
|
||||
|
||||
void* mz_stream_zlib_get_interface(void);
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,259 @@
|
|||
/* mz_zip.h -- Zip manipulation
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
Copyright (C) 2009-2010 Mathias Svensson
|
||||
Modifications for Zip64 support
|
||||
http://result42.com
|
||||
Copyright (C) 1998-2010 Gilles Vollant
|
||||
https://www.winimage.com/zLibDll/minizip.html
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
#ifndef MZ_ZIP_H
|
||||
#define MZ_ZIP_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
typedef struct mz_zip_file_s {
|
||||
uint16_t version_madeby; /* version made by */
|
||||
uint16_t version_needed; /* version needed to extract */
|
||||
uint16_t flag; /* general purpose bit flag */
|
||||
uint16_t compression_method; /* compression method */
|
||||
time_t modified_date; /* last modified date in unix time */
|
||||
time_t accessed_date; /* last accessed date in unix time */
|
||||
time_t creation_date; /* creation date in unix time */
|
||||
uint32_t crc; /* crc-32 */
|
||||
int64_t compressed_size; /* compressed size */
|
||||
int64_t uncompressed_size; /* uncompressed size */
|
||||
uint16_t filename_size; /* filename length */
|
||||
uint16_t extrafield_size; /* extra field length */
|
||||
uint16_t comment_size; /* file comment length */
|
||||
uint32_t disk_number; /* disk number start */
|
||||
int64_t disk_offset; /* relative offset of local header */
|
||||
uint16_t internal_fa; /* internal file attributes */
|
||||
uint32_t external_fa; /* external file attributes */
|
||||
|
||||
const char *filename; /* filename utf8 null-terminated string */
|
||||
const uint8_t *extrafield; /* extrafield data */
|
||||
const char *comment; /* comment utf8 null-terminated string */
|
||||
const char *linkname; /* sym-link filename utf8 null-terminated string */
|
||||
|
||||
uint16_t zip64; /* zip64 extension mode */
|
||||
uint16_t aes_version; /* winzip aes extension if not 0 */
|
||||
uint8_t aes_encryption_mode; /* winzip aes encryption mode */
|
||||
uint16_t pk_verify; /* pkware encryption verifier */
|
||||
|
||||
} mz_zip_file, mz_zip_entry;
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
typedef int32_t (*mz_zip_locate_entry_cb)(void *handle, void *userdata, mz_zip_file *file_info);
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
void * mz_zip_create(void **handle);
|
||||
/* Create zip instance for opening */
|
||||
|
||||
void mz_zip_delete(void **handle);
|
||||
/* Delete zip object */
|
||||
|
||||
int32_t mz_zip_open(void *handle, void *stream, int32_t mode);
|
||||
/* Create a zip file, no delete file in zip functionality */
|
||||
|
||||
int32_t mz_zip_close(void *handle);
|
||||
/* Close the zip file */
|
||||
|
||||
int32_t mz_zip_get_comment(void *handle, const char **comment);
|
||||
/* Get a pointer to the global comment */
|
||||
|
||||
int32_t mz_zip_set_comment(void *handle, const char *comment);
|
||||
/* Sets the global comment used for writing zip file */
|
||||
|
||||
int32_t mz_zip_get_version_madeby(void *handle, uint16_t *version_madeby);
|
||||
/* Get the version made by */
|
||||
|
||||
int32_t mz_zip_set_version_madeby(void *handle, uint16_t version_madeby);
|
||||
/* Sets the version made by used for writing zip file */
|
||||
|
||||
int32_t mz_zip_set_recover(void *handle, uint8_t recover);
|
||||
/* Sets the ability to recover the central dir by reading local file headers */
|
||||
|
||||
int32_t mz_zip_set_data_descriptor(void *handle, uint8_t data_descriptor);
|
||||
/* Sets the use of data descriptor flag when writing zip entries */
|
||||
|
||||
int32_t mz_zip_get_stream(void *handle, void **stream);
|
||||
/* Get a pointer to the stream used to open */
|
||||
|
||||
int32_t mz_zip_set_cd_stream(void *handle, int64_t cd_start_pos, void *cd_stream);
|
||||
/* Sets the stream to use for reading the central dir */
|
||||
|
||||
int32_t mz_zip_get_cd_mem_stream(void *handle, void **cd_mem_stream);
|
||||
/* Get a pointer to the stream used to store the central dir in memory */
|
||||
|
||||
int32_t mz_zip_set_number_entry(void *handle, uint64_t number_entry);
|
||||
/* Sets the total number of entries */
|
||||
|
||||
int32_t mz_zip_get_number_entry(void *handle, uint64_t *number_entry);
|
||||
/* Get the total number of entries */
|
||||
|
||||
int32_t mz_zip_set_disk_number_with_cd(void *handle, uint32_t disk_number_with_cd);
|
||||
/* Sets the disk number containing the central directory record */
|
||||
|
||||
int32_t mz_zip_get_disk_number_with_cd(void *handle, uint32_t *disk_number_with_cd);
|
||||
/* Get the disk number containing the central directory record */
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_zip_entry_is_open(void *handle);
|
||||
/* Check to see if entry is open for read/write */
|
||||
|
||||
int32_t mz_zip_entry_read_open(void *handle, uint8_t raw, const char *password);
|
||||
/* Open for reading the current file in the zip file */
|
||||
|
||||
int32_t mz_zip_entry_read(void *handle, void *buf, int32_t len);
|
||||
/* Read bytes from the current file in the zip file */
|
||||
|
||||
int32_t mz_zip_entry_read_close(void *handle, uint32_t *crc32, int64_t *compressed_size,
|
||||
int64_t *uncompressed_size);
|
||||
/* Close the current file for reading and get data descriptor values */
|
||||
|
||||
int32_t mz_zip_entry_write_open(void *handle, const mz_zip_file *file_info,
|
||||
int16_t compress_level, uint8_t raw, const char *password);
|
||||
/* Open for writing the current file in the zip file */
|
||||
|
||||
int32_t mz_zip_entry_write(void *handle, const void *buf, int32_t len);
|
||||
/* Write bytes from the current file in the zip file */
|
||||
|
||||
int32_t mz_zip_entry_write_close(void *handle, uint32_t crc32, int64_t compressed_size,
|
||||
int64_t uncompressed_size);
|
||||
/* Close the current file for writing and set data descriptor values */
|
||||
|
||||
int32_t mz_zip_entry_seek_local_header(void *handle);
|
||||
/* Seeks to the local header for the entry */
|
||||
|
||||
int32_t mz_zip_entry_close_raw(void *handle, int64_t uncompressed_size, uint32_t crc32);
|
||||
/* Close the current file in the zip file where raw is compressed data */
|
||||
|
||||
int32_t mz_zip_entry_close(void *handle);
|
||||
/* Close the current file in the zip file */
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_zip_entry_is_dir(void *handle);
|
||||
/* Checks to see if the entry is a directory */
|
||||
|
||||
int32_t mz_zip_entry_is_symlink(void *handle);
|
||||
/* Checks to see if the entry is a symbolic link */
|
||||
|
||||
int32_t mz_zip_entry_get_info(void *handle, mz_zip_file **file_info);
|
||||
/* Get info about the current file, only valid while current entry is open */
|
||||
|
||||
int32_t mz_zip_entry_get_local_info(void *handle, mz_zip_file **local_file_info);
|
||||
/* Get local info about the current file, only valid while current entry is being read */
|
||||
|
||||
int32_t mz_zip_entry_set_extrafield(void *handle, const uint8_t *extrafield, uint16_t extrafield_size);
|
||||
/* Sets or updates the extra field for the entry to be used before writing cd */
|
||||
|
||||
int64_t mz_zip_get_entry(void *handle);
|
||||
/* Return offset of the current entry in the zip file */
|
||||
|
||||
int32_t mz_zip_goto_entry(void *handle, int64_t cd_pos);
|
||||
/* Go to specified entry in the zip file */
|
||||
|
||||
int32_t mz_zip_goto_first_entry(void *handle);
|
||||
/* Go to the first entry in the zip file */
|
||||
|
||||
int32_t mz_zip_goto_next_entry(void *handle);
|
||||
/* Go to the next entry in the zip file or MZ_END_OF_LIST if reaching the end */
|
||||
|
||||
int32_t mz_zip_locate_entry(void *handle, const char *filename, uint8_t ignore_case);
|
||||
/* Locate the file with the specified name in the zip file or MZ_END_LIST if not found */
|
||||
|
||||
int32_t mz_zip_locate_first_entry(void *handle, void *userdata, mz_zip_locate_entry_cb cb);
|
||||
/* Locate the first matching entry based on a match callback */
|
||||
|
||||
int32_t mz_zip_locate_next_entry(void *handle, void *userdata, mz_zip_locate_entry_cb cb);
|
||||
/* Locate the next matching entry based on a match callback */
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_zip_attrib_is_dir(uint32_t attrib, int32_t version_madeby);
|
||||
/* Checks to see if the attribute is a directory based on platform */
|
||||
|
||||
int32_t mz_zip_attrib_is_symlink(uint32_t attrib, int32_t version_madeby);
|
||||
/* Checks to see if the attribute is a symbolic link based on platform */
|
||||
|
||||
int32_t mz_zip_attrib_convert(uint8_t src_sys, uint32_t src_attrib, uint8_t target_sys,
|
||||
uint32_t *target_attrib);
|
||||
/* Converts file attributes from one host system to another */
|
||||
|
||||
int32_t mz_zip_attrib_posix_to_win32(uint32_t posix_attrib, uint32_t *win32_attrib);
|
||||
/* Converts posix file attributes to win32 file attributes */
|
||||
|
||||
int32_t mz_zip_attrib_win32_to_posix(uint32_t win32_attrib, uint32_t *posix_attrib);
|
||||
/* Converts win32 file attributes to posix file attributes */
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_zip_extrafield_find(void *stream, uint16_t type, int32_t max_seek, uint16_t *length);
|
||||
/* Seeks to extra field by its type and returns its length */
|
||||
|
||||
int32_t mz_zip_extrafield_contains(const uint8_t *extrafield, int32_t extrafield_size,
|
||||
uint16_t type, uint16_t *length);
|
||||
/* Gets whether an extrafield exists and its size */
|
||||
|
||||
int32_t mz_zip_extrafield_read(void *stream, uint16_t *type, uint16_t *length);
|
||||
/* Reads an extrafield header from a stream */
|
||||
|
||||
int32_t mz_zip_extrafield_write(void *stream, uint16_t type, uint16_t length);
|
||||
/* Writes an extrafield header to a stream */
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_zip_dosdate_to_tm(uint64_t dos_date, struct tm *ptm);
|
||||
/* Convert dos date/time format to struct tm */
|
||||
|
||||
time_t mz_zip_dosdate_to_time_t(uint64_t dos_date);
|
||||
/* Convert dos date/time format to time_t */
|
||||
|
||||
int32_t mz_zip_time_t_to_tm(time_t unix_time, struct tm *ptm);
|
||||
/* Convert time_t to time struct */
|
||||
|
||||
uint32_t mz_zip_time_t_to_dos_date(time_t unix_time);
|
||||
/* Convert time_t to dos date/time format */
|
||||
|
||||
uint32_t mz_zip_tm_to_dosdate(const struct tm *ptm);
|
||||
/* Convert struct tm to dos date/time format */
|
||||
|
||||
int32_t mz_zip_ntfs_to_unix_time(uint64_t ntfs_time, time_t *unix_time);
|
||||
/* Convert ntfs time to unix time */
|
||||
|
||||
int32_t mz_zip_unix_to_ntfs_time(time_t unix_time, uint64_t *ntfs_time);
|
||||
/* Convert unix time to ntfs time */
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_zip_path_compare(const char *path1, const char *path2, uint8_t ignore_case);
|
||||
/* Compare two paths without regard to slashes */
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
const
|
||||
char* mz_zip_get_compression_method_string(int32_t compression_method);
|
||||
/* Gets a string representing the compression method */
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _ZIP_H */
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,285 @@
|
|||
/* mz_zip_rw.h -- Zip reader/writer
|
||||
part of the minizip-ng project
|
||||
|
||||
Copyright (C) 2010-2021 Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
|
||||
This program is distributed under the terms of the same license as zlib.
|
||||
See the accompanying LICENSE file for the full text of the license.
|
||||
*/
|
||||
|
||||
#ifndef MZ_ZIP_RW_H
|
||||
#define MZ_ZIP_RW_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
typedef int32_t (*mz_zip_reader_overwrite_cb)(void *handle, void *userdata, mz_zip_file *file_info, const char *path);
|
||||
typedef int32_t (*mz_zip_reader_password_cb)(void *handle, void *userdata, mz_zip_file *file_info, char *password, int32_t max_password);
|
||||
typedef int32_t (*mz_zip_reader_progress_cb)(void *handle, void *userdata, mz_zip_file *file_info, int64_t position);
|
||||
typedef int32_t (*mz_zip_reader_entry_cb)(void *handle, void *userdata, mz_zip_file *file_info, const char *path);
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_zip_reader_is_open(void *handle);
|
||||
/* Checks to see if the zip file is open */
|
||||
|
||||
int32_t mz_zip_reader_open(void *handle, void *stream);
|
||||
/* Opens zip file from stream */
|
||||
|
||||
int32_t mz_zip_reader_open_file(void *handle, const char *path);
|
||||
/* Opens zip file from a file path */
|
||||
|
||||
int32_t mz_zip_reader_open_file_in_memory(void *handle, const char *path);
|
||||
/* Opens zip file from a file path into memory for faster access */
|
||||
|
||||
int32_t mz_zip_reader_open_buffer(void *handle, uint8_t *buf, int32_t len, uint8_t copy);
|
||||
/* Opens zip file from memory buffer */
|
||||
|
||||
int32_t mz_zip_reader_close(void *handle);
|
||||
/* Closes the zip file */
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_zip_reader_unzip_cd(void *handle);
|
||||
/* Unzip the central directory */
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_zip_reader_goto_first_entry(void *handle);
|
||||
/* Goto the first entry in the zip file that matches the pattern */
|
||||
|
||||
int32_t mz_zip_reader_goto_next_entry(void *handle);
|
||||
/* Goto the next entry in the zip file that matches the pattern */
|
||||
|
||||
int32_t mz_zip_reader_locate_entry(void *handle, const char *filename, uint8_t ignore_case);
|
||||
/* Locates an entry by filename */
|
||||
|
||||
int32_t mz_zip_reader_entry_open(void *handle);
|
||||
/* Opens an entry for reading */
|
||||
|
||||
int32_t mz_zip_reader_entry_close(void *handle);
|
||||
/* Closes an entry */
|
||||
|
||||
int32_t mz_zip_reader_entry_read(void *handle, void *buf, int32_t len);
|
||||
/* Reads and entry after being opened */
|
||||
|
||||
int32_t mz_zip_reader_entry_has_sign(void *handle);
|
||||
/* Checks to see if the entry has a signature */
|
||||
|
||||
int32_t mz_zip_reader_entry_sign_verify(void *handle);
|
||||
/* Verifies a signature stored with the entry */
|
||||
|
||||
int32_t mz_zip_reader_entry_get_hash(void *handle, uint16_t algorithm, uint8_t *digest, int32_t digest_size);
|
||||
/* Gets a hash algorithm from the entry's extra field */
|
||||
|
||||
int32_t mz_zip_reader_entry_get_first_hash(void *handle, uint16_t *algorithm, uint16_t *digest_size);
|
||||
/* Gets the most secure hash algorithm from the entry's extra field */
|
||||
|
||||
int32_t mz_zip_reader_entry_get_info(void *handle, mz_zip_file **file_info);
|
||||
/* Gets the current entry file info */
|
||||
|
||||
int32_t mz_zip_reader_entry_is_dir(void *handle);
|
||||
/* Gets the current entry is a directory */
|
||||
|
||||
int32_t mz_zip_reader_entry_save(void *handle, void *stream, mz_stream_write_cb write_cb);
|
||||
/* Save the current entry to a stream */
|
||||
|
||||
int32_t mz_zip_reader_entry_save_process(void *handle, void *stream, mz_stream_write_cb write_cb);
|
||||
/* Saves a portion of the current entry to a stream callback */
|
||||
|
||||
int32_t mz_zip_reader_entry_save_file(void *handle, const char *path);
|
||||
/* Save the current entry to a file */
|
||||
|
||||
int32_t mz_zip_reader_entry_save_buffer(void *handle, void *buf, int32_t len);
|
||||
/* Save the current entry to a memory buffer */
|
||||
|
||||
int32_t mz_zip_reader_entry_save_buffer_length(void *handle);
|
||||
/* Gets the length of the buffer required to save */
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_zip_reader_save_all(void *handle, const char *destination_dir);
|
||||
/* Save all files into a directory */
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
void mz_zip_reader_set_pattern(void *handle, const char *pattern, uint8_t ignore_case);
|
||||
/* Sets the match pattern for entries in the zip file, if null all entries are matched */
|
||||
|
||||
void mz_zip_reader_set_password(void *handle, const char *password);
|
||||
/* Sets the password required for extraction */
|
||||
|
||||
void mz_zip_reader_set_raw(void *handle, uint8_t raw);
|
||||
/* Sets whether or not it should save the entry raw */
|
||||
|
||||
int32_t mz_zip_reader_get_raw(void *handle, uint8_t *raw);
|
||||
/* Gets whether or not it should save the entry raw */
|
||||
|
||||
int32_t mz_zip_reader_get_zip_cd(void *handle, uint8_t *zip_cd);
|
||||
/* Gets whether or not the archive has a zipped central directory */
|
||||
|
||||
int32_t mz_zip_reader_get_comment(void *handle, const char **comment);
|
||||
/* Gets the comment for the central directory */
|
||||
|
||||
int32_t mz_zip_reader_set_recover(void *handle, uint8_t recover);
|
||||
/* Sets the ability to recover the central dir by reading local file headers */
|
||||
|
||||
void mz_zip_reader_set_encoding(void *handle, int32_t encoding);
|
||||
/* Sets whether or not it should support a special character encoding in zip file names. */
|
||||
|
||||
void mz_zip_reader_set_sign_required(void *handle, uint8_t sign_required);
|
||||
/* Sets whether or not it a signature is required */
|
||||
|
||||
void mz_zip_reader_set_overwrite_cb(void *handle, void *userdata, mz_zip_reader_overwrite_cb cb);
|
||||
/* Callback for what to do when a file is being overwritten */
|
||||
|
||||
void mz_zip_reader_set_password_cb(void *handle, void *userdata, mz_zip_reader_password_cb cb);
|
||||
/* Callback for when a password is required and hasn't been set */
|
||||
|
||||
void mz_zip_reader_set_progress_cb(void *handle, void *userdata, mz_zip_reader_progress_cb cb);
|
||||
/* Callback for extraction progress */
|
||||
|
||||
void mz_zip_reader_set_progress_interval(void *handle, uint32_t milliseconds);
|
||||
/* Let at least milliseconds pass between calls to progress callback */
|
||||
|
||||
void mz_zip_reader_set_entry_cb(void *handle, void *userdata, mz_zip_reader_entry_cb cb);
|
||||
/* Callback for zip file entries */
|
||||
|
||||
int32_t mz_zip_reader_get_zip_handle(void *handle, void **zip_handle);
|
||||
/* Gets the underlying zip instance handle */
|
||||
|
||||
void* mz_zip_reader_create(void **handle);
|
||||
/* Create new instance of zip reader */
|
||||
|
||||
void mz_zip_reader_delete(void **handle);
|
||||
/* Delete instance of zip reader */
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
typedef int32_t (*mz_zip_writer_overwrite_cb)(void *handle, void *userdata, const char *path);
|
||||
typedef int32_t (*mz_zip_writer_password_cb)(void *handle, void *userdata, mz_zip_file *file_info, char *password, int32_t max_password);
|
||||
typedef int32_t (*mz_zip_writer_progress_cb)(void *handle, void *userdata, mz_zip_file *file_info, int64_t position);
|
||||
typedef int32_t (*mz_zip_writer_entry_cb)(void *handle, void *userdata, mz_zip_file *file_info);
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_zip_writer_is_open(void *handle);
|
||||
/* Checks to see if the zip file is open */
|
||||
|
||||
int32_t mz_zip_writer_open(void *handle, void *stream, uint8_t append);
|
||||
/* Opens zip file from stream */
|
||||
|
||||
int32_t mz_zip_writer_open_file(void *handle, const char *path, int64_t disk_size, uint8_t append);
|
||||
/* Opens zip file from a file path */
|
||||
|
||||
int32_t mz_zip_writer_open_file_in_memory(void *handle, const char *path);
|
||||
/* Opens zip file from a file path into memory for faster access */
|
||||
|
||||
int32_t mz_zip_writer_close(void *handle);
|
||||
/* Closes the zip file */
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_zip_writer_entry_open(void *handle, mz_zip_file *file_info);
|
||||
/* Opens an entry in the zip file for writing */
|
||||
|
||||
int32_t mz_zip_writer_entry_close(void *handle);
|
||||
/* Closes entry in zip file */
|
||||
|
||||
int32_t mz_zip_writer_entry_write(void *handle, const void *buf, int32_t len);
|
||||
/* Writes data into entry for zip */
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
int32_t mz_zip_writer_add(void *handle, void *stream, mz_stream_read_cb read_cb);
|
||||
/* Writes all data to the currently open entry in the zip */
|
||||
|
||||
int32_t mz_zip_writer_add_process(void *handle, void *stream, mz_stream_read_cb read_cb);
|
||||
/* Writes a portion of data to the currently open entry in the zip */
|
||||
|
||||
int32_t mz_zip_writer_add_info(void *handle, void *stream, mz_stream_read_cb read_cb, mz_zip_file *file_info);
|
||||
/* Adds an entry to the zip based on the info */
|
||||
|
||||
int32_t mz_zip_writer_add_buffer(void *handle, void *buf, int32_t len, mz_zip_file *file_info);
|
||||
/* Adds an entry to the zip with a memory buffer */
|
||||
|
||||
int32_t mz_zip_writer_add_file(void *handle, const char *path, const char *filename_in_zip);
|
||||
/* Adds an entry to the zip from a file */
|
||||
|
||||
int32_t mz_zip_writer_add_path(void *handle, const char *path, const char *root_path, uint8_t include_path,
|
||||
uint8_t recursive);
|
||||
/* Enumerates a directory or pattern and adds entries to the zip */
|
||||
|
||||
int32_t mz_zip_writer_copy_from_reader(void *handle, void *reader);
|
||||
/* Adds an entry from a zip reader instance */
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
void mz_zip_writer_set_password(void *handle, const char *password);
|
||||
/* Password to use for encrypting files in the zip */
|
||||
|
||||
void mz_zip_writer_set_comment(void *handle, const char *comment);
|
||||
/* Comment to use for the archive */
|
||||
|
||||
void mz_zip_writer_set_raw(void *handle, uint8_t raw);
|
||||
/* Sets whether or not we should write the entry raw */
|
||||
|
||||
int32_t mz_zip_writer_get_raw(void *handle, uint8_t *raw);
|
||||
/* Gets whether or not we should write the entry raw */
|
||||
|
||||
void mz_zip_writer_set_aes(void *handle, uint8_t aes);
|
||||
/* Use aes encryption when adding files in zip */
|
||||
|
||||
void mz_zip_writer_set_compress_method(void *handle, uint16_t compress_method);
|
||||
/* Sets the compression method when adding files in zip */
|
||||
|
||||
void mz_zip_writer_set_compress_level(void *handle, int16_t compress_level);
|
||||
/* Sets the compression level when adding files in zip */
|
||||
|
||||
void mz_zip_writer_set_follow_links(void *handle, uint8_t follow_links);
|
||||
/* Follow symbolic links when traversing directories and files to add */
|
||||
|
||||
void mz_zip_writer_set_store_links(void *handle, uint8_t store_links);
|
||||
/* Store symbolic links in zip file */
|
||||
|
||||
void mz_zip_writer_set_zip_cd(void *handle, uint8_t zip_cd);
|
||||
/* Sets whether or not central directory should be zipped */
|
||||
|
||||
int32_t mz_zip_writer_set_certificate(void *handle, const char *cert_path, const char *cert_pwd);
|
||||
/* Sets the certificate and timestamp url to use for signing when adding files in zip */
|
||||
|
||||
void mz_zip_writer_set_overwrite_cb(void *handle, void *userdata, mz_zip_writer_overwrite_cb cb);
|
||||
/* Callback for what to do when zip file already exists */
|
||||
|
||||
void mz_zip_writer_set_password_cb(void *handle, void *userdata, mz_zip_writer_password_cb cb);
|
||||
/* Callback for ask if a password is required for adding */
|
||||
|
||||
void mz_zip_writer_set_progress_cb(void *handle, void *userdata, mz_zip_writer_progress_cb cb);
|
||||
/* Callback for compression progress */
|
||||
|
||||
void mz_zip_writer_set_progress_interval(void *handle, uint32_t milliseconds);
|
||||
/* Let at least milliseconds pass between calls to progress callback */
|
||||
|
||||
void mz_zip_writer_set_entry_cb(void *handle, void *userdata, mz_zip_writer_entry_cb cb);
|
||||
/* Callback for zip file entries */
|
||||
|
||||
int32_t mz_zip_writer_get_zip_handle(void *handle, void **zip_handle);
|
||||
/* Gets the underlying zip handle */
|
||||
|
||||
void* mz_zip_writer_create(void **handle);
|
||||
/* Create new instance of zip writer */
|
||||
|
||||
void mz_zip_writer_delete(void **handle);
|
||||
/* Delete instance of zip writer */
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,233 @@
|
|||
#import <Foundation/Foundation.h>
|
||||
#import <UIKit/UIKit.h>
|
||||
#import <mach-o/dyld.h>
|
||||
|
||||
@interface NSString (GKMSCompat)
|
||||
- (const char*)UTF8String;
|
||||
- (NSString*)stringByAppendingPathComponent:(NSString*)str;
|
||||
@end
|
||||
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
|
||||
#include <dlfcn.h>
|
||||
#include <os/log.h>
|
||||
|
||||
#include "UpdateChecker.h"
|
||||
|
||||
extern "C" void InitHook(void* unityFramework, void* unityBaseAddress,
|
||||
const char* unityFrameworkPath,
|
||||
const char* configJsonStr,
|
||||
const char* localizationBaseDir);
|
||||
|
||||
extern "C" void GKMSShowToastIOS(const char* text);
|
||||
|
||||
namespace {
|
||||
|
||||
std::string ToStdString(NSString* str) {
|
||||
if (!str) return "";
|
||||
return {[str UTF8String]};
|
||||
}
|
||||
|
||||
std::string GetDocumentsPath() {
|
||||
NSArray<NSString*>* paths = NSSearchPathForDirectoriesInDomains(
|
||||
NSDocumentDirectory, NSUserDomainMask, YES);
|
||||
if (!paths || [paths count] == 0) return "";
|
||||
return ToStdString([paths objectAtIndex:0]);
|
||||
}
|
||||
|
||||
std::string ReadWholeFile(const std::filesystem::path& path) {
|
||||
std::ifstream in(path);
|
||||
if (!in.is_open()) return "";
|
||||
std::ostringstream ss;
|
||||
ss << in.rdbuf();
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
std::string g_unityFrameworkPath;
|
||||
|
||||
UIView* GetToastContainerView() {
|
||||
UIWindow *targetWindow = nil;
|
||||
if (@available(iOS 13.0, *)) {
|
||||
for (UIScene *scene in [UIApplication sharedApplication].connectedScenes) {
|
||||
if (![scene isKindOfClass:[UIWindowScene class]]) continue;
|
||||
UIWindowScene *windowScene = (UIWindowScene *)scene;
|
||||
if (windowScene.activationState != UISceneActivationStateForegroundActive) continue;
|
||||
for (UIWindow *window in windowScene.windows) {
|
||||
if (window.isHidden) continue;
|
||||
if (window.isKeyWindow) {
|
||||
targetWindow = window;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (targetWindow) break;
|
||||
}
|
||||
} else {
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
|
||||
targetWindow = [UIApplication sharedApplication].keyWindow;
|
||||
#pragma clang diagnostic pop
|
||||
}
|
||||
|
||||
if (!targetWindow) {
|
||||
targetWindow = [UIApplication sharedApplication].windows.firstObject;
|
||||
}
|
||||
return targetWindow;
|
||||
}
|
||||
|
||||
void* OpenUnityFramework() {
|
||||
/*
|
||||
NSString* exePath = [[NSBundle mainBundle] executablePath];
|
||||
if (!exePath) return nullptr;
|
||||
|
||||
std::filesystem::path p(ToStdString(exePath));
|
||||
auto frameworkPath =
|
||||
p.parent_path() / "Frameworks" / "UnityFramework.framework" / "UnityFramework";
|
||||
|
||||
if (std::filesystem::exists(frameworkPath)) {
|
||||
g_unityFrameworkPath = frameworkPath.string();
|
||||
return dlopen(frameworkPath.c_str(), RTLD_NOW);
|
||||
}
|
||||
return dlopen(nullptr, RTLD_NOW);*/
|
||||
|
||||
NSString* const frameworkPath = [[NSBundle mainBundle] privateFrameworksPath];
|
||||
NSString* const frameworkName = @"UnityFramework.framework/UnityFramework";
|
||||
NSString* const frameworkFullPath = [frameworkPath stringByAppendingPathComponent:frameworkName];
|
||||
const char* const frameworkFullPathCString = [frameworkFullPath UTF8String];
|
||||
return dlopen(frameworkFullPathCString, RTLD_LAZY);
|
||||
}
|
||||
|
||||
uintptr_t GetUnityFrameworkBaseAddress() {
|
||||
uint32_t imageCount = _dyld_image_count();
|
||||
|
||||
for (uint32_t i = 0; i < imageCount; i++) {
|
||||
const char *imageName = _dyld_get_image_name(i);
|
||||
|
||||
// 匹配加载的模块名称
|
||||
if (imageName && strstr(imageName, "UnityFramework")) {
|
||||
// 获取该模块的 Mach-O Header 指针，也就是内存加载基址
|
||||
uintptr_t baseAddress = (uintptr_t)_dyld_get_image_header(i);
|
||||
return baseAddress;
|
||||
}
|
||||
}
|
||||
return 0; // 未找到
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
void StartInitMyPlugin()
|
||||
{
|
||||
os_log(OS_LOG_DEFAULT, "GakumasLocalify: constructor called");
|
||||
|
||||
const std::string docPath = GetDocumentsPath();
|
||||
if (docPath.empty()) {
|
||||
os_log_error(OS_LOG_DEFAULT, "GakumasLocalify: cannot find Documents path");
|
||||
return;
|
||||
}
|
||||
|
||||
const std::filesystem::path baseDir =
|
||||
std::filesystem::path(docPath) / "gakumas-localify";
|
||||
const std::filesystem::path localFilesDir = baseDir / "local-files";
|
||||
const std::filesystem::path configPath = baseDir / "config.json";
|
||||
|
||||
CheckForUpdates(baseDir.string());
|
||||
os_log(OS_LOG_DEFAULT, "GakumasLocalify: Update check finished.");
|
||||
|
||||
std::error_code ec;
|
||||
std::filesystem::create_directories(localFilesDir, ec);
|
||||
|
||||
std::string configJson = ReadWholeFile(configPath);
|
||||
if (configJson.empty()) {
|
||||
configJson = "{}";
|
||||
}
|
||||
|
||||
void* unityHandle = OpenUnityFramework();
|
||||
if (!unityHandle) {
|
||||
const char* err = dlerror();
|
||||
os_log_error(OS_LOG_DEFAULT, "GakumasLocalify: failed to open UnityFramework: %{public}s",
|
||||
err ? err : "(no dlerror)");
|
||||
return;
|
||||
}
|
||||
|
||||
void* unityBaseAddress = (void*)GetUnityFrameworkBaseAddress();
|
||||
|
||||
os_log(OS_LOG_DEFAULT, "GakumasLocalify: UnityFramework handle=%p, baseAddress=%p", unityHandle, unityBaseAddress);
|
||||
|
||||
void* testSym = dlsym(unityHandle, "il2cpp_init");
|
||||
os_log(OS_LOG_DEFAULT, "GakumasLocalify: quick test dlsym(handle, il2cpp_init)=%p, dlerror=%{public}s",
|
||||
testSym, dlerror() ?: "(none)");
|
||||
|
||||
os_log(OS_LOG_DEFAULT, "GakumasLocalify: calling InitHook");
|
||||
InitHook(unityHandle, unityBaseAddress, g_unityFrameworkPath.c_str(),
|
||||
configJson.c_str(), baseDir.string().c_str());
|
||||
}
|
||||
|
||||
static void OnAppDidFinishLaunching(CFNotificationCenterRef center, void *observer, CFStringRef name, const void *object, CFDictionaryRef userInfo) {
|
||||
StartInitMyPlugin();
|
||||
}
|
||||
|
||||
__attribute__((constructor)) static void GakumasLocalifyIOSInit() {
|
||||
dispatch_async(dispatch_get_main_queue(), ^{
|
||||
dispatch_async(
|
||||
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
||||
StartInitMyPlugin();
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
extern "C" void GKMSShowToastIOS(const char* text) {
|
||||
if (!text || text[0] == '\0') return;
|
||||
|
||||
NSString *message = [NSString stringWithUTF8String:text];
|
||||
if (!message || message.length == 0) return;
|
||||
|
||||
dispatch_async(dispatch_get_main_queue(), ^{
|
||||
UIView *container = GetToastContainerView();
|
||||
if (!container) {
|
||||
os_log(OS_LOG_DEFAULT, "GakumasLocalify: toast container unavailable");
|
||||
return;
|
||||
}
|
||||
|
||||
UILabel *toastLabel = [[UILabel alloc] init];
|
||||
toastLabel.text = message;
|
||||
toastLabel.numberOfLines = 0;
|
||||
toastLabel.textAlignment = NSTextAlignmentCenter;
|
||||
toastLabel.textColor = [UIColor whiteColor];
|
||||
toastLabel.backgroundColor = [[UIColor blackColor] colorWithAlphaComponent:0.82];
|
||||
toastLabel.font = [UIFont systemFontOfSize:14.0 weight:UIFontWeightMedium];
|
||||
toastLabel.layer.cornerRadius = 10.0;
|
||||
toastLabel.layer.masksToBounds = YES;
|
||||
toastLabel.alpha = 0.0;
|
||||
|
||||
const CGFloat horizontalPadding = 14.0;
|
||||
const CGFloat verticalPadding = 10.0;
|
||||
const CGFloat margin = 24.0;
|
||||
const CGFloat maxWidth = CGRectGetWidth(container.bounds) - margin * 2.0;
|
||||
const CGSize maxSize = CGSizeMake(MAX(120.0, maxWidth - horizontalPadding * 2.0), CGFLOAT_MAX);
|
||||
CGRect textRect = [message boundingRectWithSize:maxSize
|
||||
options:(NSStringDrawingUsesLineFragmentOrigin | NSStringDrawingUsesFontLeading)
|
||||
attributes:@{NSFontAttributeName: toastLabel.font}
|
||||
context:nil];
|
||||
CGSize textSize = CGSizeMake(ceil(textRect.size.width), ceil(textRect.size.height));
|
||||
CGFloat finalWidth = MIN(maxWidth, textSize.width + horizontalPadding * 2.0);
|
||||
CGFloat finalHeight = textSize.height + verticalPadding * 2.0;
|
||||
CGFloat x = (CGRectGetWidth(container.bounds) - finalWidth) * 0.5;
|
||||
CGFloat y = CGRectGetHeight(container.bounds) * 0.80 - finalHeight;
|
||||
toastLabel.frame = CGRectMake(MAX(margin, x), MAX(80.0, y), finalWidth, finalHeight);
|
||||
|
||||
[container addSubview:toastLabel];
|
||||
[UIView animateWithDuration:0.18 animations:^{
|
||||
toastLabel.alpha = 1.0;
|
||||
} completion:^(__unused BOOL finished) {
|
||||
[UIView animateWithDuration:0.28
|
||||
delay:1.55
|
||||
options:UIViewAnimationOptionCurveEaseInOut
|
||||
animations:^{
|
||||
toastLabel.alpha = 0.0;
|
||||
} completion:^(__unused BOOL finished2) {
|
||||
[toastLabel removeFromSuperview];
|
||||
}];
|
||||
}];
|
||||
});
|
||||
}
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
#pragma once
|
||||
|
||||
#include "../GakumasLocalify/GakumasLocalify/Plugin.h"
|
||||
|
||||
class IOSHookInstaller final : public GakumasLocal::HookInstaller {
|
||||
public:
|
||||
explicit IOSHookInstaller(void* unityFramework);
|
||||
~IOSHookInstaller() override;
|
||||
|
||||
void* InstallHook(void* addr, void* hook, void** orig) override;
|
||||
GakumasLocal::OpaqueFunctionPointer LookupSymbol(const char* name) override;
|
||||
|
||||
private:
|
||||
void* m_unityFramework = nullptr;
|
||||
};
|
||||
|
|
@ -0,0 +1,217 @@
|
|||
#include "IOSHookInstaller.h"
|
||||
#include "../GakumasLocalify/GakumasLocalify/Log.h"
|
||||
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include <dlfcn.h>
|
||||
#include <mach-o/dyld.h>
|
||||
#include <mach-o/loader.h>
|
||||
#include <mach-o/nlist.h>
|
||||
|
||||
namespace {
|
||||
using MSHookFunctionType = void (*)(void* symbol, void* replace, void** result);
|
||||
|
||||
MSHookFunctionType ResolveMSHookFunction() {
|
||||
MSHookFunctionType ret;
|
||||
if (@available(iOS 26.0, *)) {
|
||||
GakumasLocal::Log::InfoFmt("iOS 26+, Use DobbyHook");
|
||||
ret = (MSHookFunctionType)dlsym(RTLD_DEFAULT, "DobbyHook");
|
||||
} else {
|
||||
GakumasLocal::Log::InfoFmt("Not iOS 26+, Use MSHookFunction");
|
||||
ret = (MSHookFunctionType)dlsym(RTLD_DEFAULT, "MSHookFunction");
|
||||
}
|
||||
GakumasLocal::Log::InfoFmt("Hook func at %p", ret);
|
||||
return ret;
|
||||
|
||||
/*
|
||||
auto fn = reinterpret_cast<MSHookFunctionType>(dlsym(RTLD_DEFAULT, "MSHookFunction"));
|
||||
if (!fn) {
|
||||
GakumasLocal::Log::Error("MSHookFunction symbol not found — make sure CydiaSubstrate is loaded");
|
||||
}
|
||||
return fn;*/
|
||||
}
|
||||
|
||||
void DumpLoadedImages() {
|
||||
uint32_t imageCount = _dyld_image_count();
|
||||
GakumasLocal::Log::InfoFmt("=== Loaded dyld images: %u ===", imageCount);
|
||||
for (uint32_t i = 0; i < imageCount; i++) {
|
||||
const char* name = _dyld_get_image_name(i);
|
||||
const struct mach_header* header = _dyld_get_image_header(i);
|
||||
GakumasLocal::Log::InfoFmt(" [%u] %p %s", i, header, name ? name : "(null)");
|
||||
}
|
||||
}
|
||||
|
||||
struct MachOSymtabInfo {
|
||||
const struct nlist_64* symbols = nullptr;
|
||||
const char* strtab = nullptr;
|
||||
uint32_t nsyms = 0;
|
||||
intptr_t slide = 0;
|
||||
};
|
||||
|
||||
bool GetSymtabForImage(const char* filterImageName, MachOSymtabInfo& out) {
|
||||
uint32_t imageCount = _dyld_image_count();
|
||||
for (uint32_t i = 0; i < imageCount; i++) {
|
||||
const char* imageName = _dyld_get_image_name(i);
|
||||
if (!imageName) continue;
|
||||
if (filterImageName && !strstr(imageName, filterImageName)) continue;
|
||||
|
||||
const auto* header =
|
||||
reinterpret_cast<const struct mach_header_64*>(_dyld_get_image_header(i));
|
||||
if (!header || header->magic != MH_MAGIC_64) continue;
|
||||
|
||||
out.slide = _dyld_get_image_vmaddr_slide(i);
|
||||
|
||||
const struct load_command* cmd =
|
||||
reinterpret_cast<const struct load_command*>(header + 1);
|
||||
const struct symtab_command* symtabCmd = nullptr;
|
||||
const struct segment_command_64* linkeditSeg = nullptr;
|
||||
|
||||
for (uint32_t j = 0; j < header->ncmds; j++) {
|
||||
if (cmd->cmd == LC_SYMTAB) {
|
||||
symtabCmd = reinterpret_cast<const struct symtab_command*>(cmd);
|
||||
}
|
||||
if (cmd->cmd == LC_SEGMENT_64) {
|
||||
auto seg = reinterpret_cast<const struct segment_command_64*>(cmd);
|
||||
if (strcmp(seg->segname, SEG_LINKEDIT) == 0) {
|
||||
linkeditSeg = seg;
|
||||
}
|
||||
}
|
||||
cmd = reinterpret_cast<const struct load_command*>(
|
||||
reinterpret_cast<uintptr_t>(cmd) + cmd->cmdsize);
|
||||
}
|
||||
|
||||
if (!symtabCmd || !linkeditSeg) continue;
|
||||
|
||||
uintptr_t linkeditBase =
|
||||
static_cast<uintptr_t>(out.slide) + linkeditSeg->vmaddr - linkeditSeg->fileoff;
|
||||
|
||||
out.symbols = reinterpret_cast<const struct nlist_64*>(linkeditBase + symtabCmd->symoff);
|
||||
out.strtab = reinterpret_cast<const char*>(linkeditBase + symtabCmd->stroff);
|
||||
out.nsyms = symtabCmd->nsyms;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void* LookupSymbolInNlist(const char* filterImageName, const char* symbolName) {
|
||||
MachOSymtabInfo info;
|
||||
if (!GetSymtabForImage(filterImageName, info)) return nullptr;
|
||||
|
||||
const char* bareSymbol = symbolName;
|
||||
char prefixed[256];
|
||||
snprintf(prefixed, sizeof(prefixed), "_%s", symbolName);
|
||||
|
||||
for (uint32_t k = 0; k < info.nsyms; k++) {
|
||||
const char* symName = info.strtab + info.symbols[k].n_un.n_strx;
|
||||
uint8_t ntype = info.symbols[k].n_type & N_TYPE;
|
||||
if (ntype == N_UNDF) continue;
|
||||
|
||||
if (strcmp(symName, bareSymbol) == 0 || strcmp(symName, prefixed) == 0) {
|
||||
uintptr_t addr = info.symbols[k].n_value;
|
||||
if (addr != 0) addr += info.slide;
|
||||
GakumasLocal::Log::InfoFmt("LookupSymbolInNlist: found '%s' as '%s' @ 0x%lx",
|
||||
symbolName, symName, (unsigned long)addr);
|
||||
return reinterpret_cast<void*>(addr);
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void DumpSymbolsFromImage(const char* filterImageName, const char* filterSymbol) {
|
||||
MachOSymtabInfo info;
|
||||
if (!GetSymtabForImage(filterImageName, info)) {
|
||||
GakumasLocal::Log::Error("DumpSymbolsFromImage: could not find image or parse symtab");
|
||||
return;
|
||||
}
|
||||
|
||||
GakumasLocal::Log::InfoFmt("=== Symbols matching '%s' in '%s' (total=%u, slide=0x%lx) ===",
|
||||
filterSymbol ? filterSymbol : "*",
|
||||
filterImageName ? filterImageName : "*",
|
||||
info.nsyms, (unsigned long)info.slide);
|
||||
|
||||
int matchCount = 0;
|
||||
for (uint32_t k = 0; k < info.nsyms; k++) {
|
||||
const char* symName = info.strtab + info.symbols[k].n_un.n_strx;
|
||||
|
||||
if (filterSymbol && !strstr(symName, filterSymbol)) continue;
|
||||
|
||||
uint8_t type = info.symbols[k].n_type;
|
||||
bool isExternal = (type & N_EXT) != 0;
|
||||
bool isDefined = (type & N_TYPE) != N_UNDF;
|
||||
uintptr_t addr = info.symbols[k].n_value;
|
||||
if (isDefined && addr != 0) addr += info.slide;
|
||||
|
||||
GakumasLocal::Log::InfoFmt(" [%s%s] %s @ 0x%lx",
|
||||
isDefined ? "DEF" : "UND",
|
||||
isExternal ? ",EXT" : "",
|
||||
symName,
|
||||
(unsigned long)addr);
|
||||
matchCount++;/*
|
||||
if (matchCount >= 500) {
|
||||
GakumasLocal::Log::Info(" ... (truncated, too many matches)");
|
||||
break;
|
||||
}*/
|
||||
}
|
||||
GakumasLocal::Log::InfoFmt(" Matched symbols: %d", matchCount);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
IOSHookInstaller::IOSHookInstaller(void* unityFramework)
|
||||
: m_unityFramework(unityFramework) {
|
||||
}
|
||||
|
||||
IOSHookInstaller::~IOSHookInstaller() = default;
|
||||
|
||||
void* IOSHookInstaller::InstallHook(void* addr, void* hook, void** orig) {
|
||||
if (!addr || !hook || !orig) {
|
||||
return reinterpret_cast<void*>(1);
|
||||
}
|
||||
|
||||
static MSHookFunctionType msHookFunction = ResolveMSHookFunction();
|
||||
if (!msHookFunction) {
|
||||
return reinterpret_cast<void*>(2);
|
||||
}
|
||||
|
||||
msHookFunction(addr, hook, orig);
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
GakumasLocal::OpaqueFunctionPointer IOSHookInstaller::LookupSymbol(const char* name) {
|
||||
if (!name) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (m_unityFramework) {
|
||||
if (void* sym = dlsym(m_unityFramework, name)) {
|
||||
GakumasLocal::Log::InfoFmt("LookupSymbol: found '%s' via dlsym(handle) at %p", name, sym);
|
||||
return reinterpret_cast<GakumasLocal::OpaqueFunctionPointer>(sym);
|
||||
}
|
||||
const char* err1 = dlerror();
|
||||
GakumasLocal::Log::ErrorFmt("LookupSymbol: dlsym(handle, \"%s\") failed: %s",
|
||||
name, err1 ? err1 : "(no dlerror)");
|
||||
} else {
|
||||
GakumasLocal::Log::Error("LookupSymbol: m_unityFramework handle is NULL!");
|
||||
}
|
||||
|
||||
if (void* sym = dlsym(RTLD_DEFAULT, name)) {
|
||||
GakumasLocal::Log::InfoFmt("LookupSymbol: found '%s' via dlsym(RTLD_DEFAULT) at %p", name, sym);
|
||||
return reinterpret_cast<GakumasLocal::OpaqueFunctionPointer>(sym);
|
||||
}
|
||||
const char* err2 = dlerror();
|
||||
GakumasLocal::Log::ErrorFmt("LookupSymbol: dlsym(RTLD_DEFAULT, \"%s\") failed: %s",
|
||||
name, err2 ? err2 : "(no dlerror)");
|
||||
|
||||
GakumasLocal::Log::InfoFmt("LookupSymbol: dlsym failed for '%s', trying nlist fallback...", name);
|
||||
if (void* sym = LookupSymbolInNlist("UnityFramework", name)) {
|
||||
return reinterpret_cast<GakumasLocal::OpaqueFunctionPointer>(sym);
|
||||
}
|
||||
|
||||
GakumasLocal::Log::ErrorFmt("LookupSymbol: '%s' not found anywhere — dumping debug info...", name);
|
||||
// DumpLoadedImages();
|
||||
DumpSymbolsFromImage("UnityFramework", "il2cpp");
|
||||
GakumasLocal::Log::Info("=== Dumping ALL symbols from UnityFramework ===");
|
||||
DumpSymbolsFromImage("UnityFramework", nullptr);
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
#include "../GakumasLocalify/GakumasLocalify/Plugin.h"
|
||||
#include "../GakumasLocalify/GakumasLocalify/config/Config.hpp"
|
||||
#include "../GakumasLocalify/GakumasLocalify/Log.h"
|
||||
#include "../il2cpp_dump/il2cppTypes.hpp"
|
||||
#include "IOSHookInstaller.h"
|
||||
|
||||
#include <dlfcn.h>
|
||||
#include <os/log.h>
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
|
||||
// JavaVM* g_javaVM = nullptr;
|
||||
// jclass g_gakumasHookMainClass = nullptr;
|
||||
// jmethodID showToastMethodId = nullptr;
|
||||
|
||||
std::filesystem::path gakumasLocalPath;
|
||||
|
||||
namespace {
|
||||
|
||||
std::string ReadWholeFile(const std::filesystem::path& path) {
|
||||
std::ifstream in(path);
|
||||
if (!in.is_open()) {
|
||||
return "";
|
||||
}
|
||||
std::ostringstream ss;
|
||||
ss << in.rdbuf();
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
extern "C" void InitHook(void* unityFramework, void* unityBaseAddress,
|
||||
const char* unityFrameworkPath,
|
||||
const char* configJsonStr,
|
||||
const char* localizationBaseDir) {
|
||||
GakumasLocal::Log::InfoFmt("Init hook localizationBaseDir: %s", localizationBaseDir);
|
||||
GakumasLocal::Log::InfoFmt("Init hook configJsonStr: %s", configJsonStr);
|
||||
|
||||
const std::string configJson =
|
||||
(configJsonStr && configJsonStr[0] != '\0') ? configJsonStr : "{}";
|
||||
GakumasLocal::Config::LoadConfig(configJson);
|
||||
|
||||
GakumasLocal::Log::Info("Config loaded");
|
||||
|
||||
const std::string baseDir =
|
||||
(localizationBaseDir && localizationBaseDir[0] != '\0')
|
||||
? localizationBaseDir
|
||||
: "";
|
||||
gakumasLocalPath = baseDir;
|
||||
|
||||
auto installer = std::make_unique<IOSHookInstaller>(unityFramework);
|
||||
installer->localizationFilesDir = baseDir;
|
||||
if (unityFrameworkPath && unityFrameworkPath[0] != '\0') {
|
||||
installer->m_il2cppLibraryPath = unityFrameworkPath;
|
||||
}
|
||||
GakumasLocal::Plugin::GetInstance().SetHookInstaller(std::move(installer));
|
||||
|
||||
Il2cppJson::Init(reinterpret_cast<uintptr_t>(unityBaseAddress));
|
||||
GakumasLocal::Plugin::GetInstance().InstallHook(/*std::move(installer)*/);
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <atomic>
|
||||
|
||||
extern std::atomic<bool> g_updateCheckDone;
|
||||
|
||||
void CheckForUpdates(const std::string& baseDir);
|
||||
|
|
@ -0,0 +1,654 @@
|
|||
#if defined(__has_feature) && __has_feature(modules)
|
||||
@import UIKit;
|
||||
#else
|
||||
#import <UIKit/UIKit.h>
|
||||
#endif
|
||||
|
||||
#import <Foundation/Foundation.h>
|
||||
#include <string>
|
||||
#include <atomic>
|
||||
#include <os/log.h>
|
||||
#import "includes/SSZipArchive/SSZipArchive.h"
|
||||
|
||||
std::atomic<bool> g_updateCheckDone{false};
|
||||
|
||||
#pragma mark - Configuration
|
||||
|
||||
// TODO: fill in GitHub repo paths (e.g., "owner/repo")
|
||||
static NSString * const kIl2cppRepo = @"https://uma.chinosk6.cn/api/gkms_ios_maps";
|
||||
static NSString * const kTransRepo = @"https://uma.chinosk6.cn/api/gkms_trans_data";
|
||||
|
||||
#pragma mark - Utility Functions
|
||||
|
||||
static NSString* TrimString(NSString *str) {
|
||||
if (!str) return nil;
|
||||
return [str stringByTrimmingCharactersInSet:
|
||||
[NSCharacterSet whitespaceAndNewlineCharacterSet]];
|
||||
}
|
||||
|
||||
static NSString* ReadFileContent(NSString *path) {
|
||||
NSError *error = nil;
|
||||
NSString *content = [NSString stringWithContentsOfFile:path
|
||||
encoding:NSUTF8StringEncoding error:&error];
|
||||
if (error || !content) return nil;
|
||||
return TrimString(content);
|
||||
}
|
||||
|
||||
static BOOL WriteFileContent(NSString *path, NSString *content) {
|
||||
NSError *error = nil;
|
||||
[content writeToFile:path atomically:YES
|
||||
encoding:NSUTF8StringEncoding error:&error];
|
||||
return error == nil;
|
||||
}
|
||||
|
||||
static NSString* FormatBytes(int64_t bytes) {
|
||||
if (bytes < 1024) return [NSString stringWithFormat:@"%lld B", bytes];
|
||||
if (bytes < 1048576) return [NSString stringWithFormat:@"%.1f KB", bytes / 1024.0];
|
||||
return [NSString stringWithFormat:@"%.2f MB", bytes / 1048576.0];
|
||||
}
|
||||
|
||||
static NSString* MakeProgressBar(float progress) {
|
||||
const int kWidth = 20;
|
||||
int filled = (int)(progress * kWidth);
|
||||
filled = MAX(0, MIN(kWidth, filled));
|
||||
NSMutableString *bar = [NSMutableString stringWithCapacity:kWidth + 2];
|
||||
[bar appendString:@"["];
|
||||
for (int i = 0; i < kWidth; i++)
|
||||
[bar appendString:(i < filled) ? @"█" : @"░"];
|
||||
[bar appendString:@"]"];
|
||||
return bar;
|
||||
}
|
||||
|
||||
static void PumpRunLoop(NSTimeInterval seconds) {
|
||||
CFRunLoopRunInMode(kCFRunLoopDefaultMode, seconds, YES);
|
||||
}
|
||||
|
||||
static void PerformOnMainWait(void(^block)(void)) {
|
||||
if ([NSThread isMainThread]) {
|
||||
block();
|
||||
return;
|
||||
}
|
||||
dispatch_semaphore_t sem = dispatch_semaphore_create(0);
|
||||
CFRunLoopPerformBlock(CFRunLoopGetMain(), kCFRunLoopDefaultMode, ^{
|
||||
@autoreleasepool { block(); }
|
||||
dispatch_semaphore_signal(sem);
|
||||
});
|
||||
CFRunLoopWakeUp(CFRunLoopGetMain());
|
||||
dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
|
||||
}
|
||||
|
||||
#pragma mark - Passthrough Window
|
||||
|
||||
@interface GKMSAlertWindow : UIWindow
|
||||
@end
|
||||
|
||||
@implementation GKMSAlertWindow
|
||||
|
||||
- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event {
|
||||
if (!self.rootViewController.presentedViewController) {
|
||||
return NO;
|
||||
}
|
||||
return [super pointInside:point withEvent:event];
|
||||
}
|
||||
|
||||
@end
|
||||
|
||||
#pragma mark - Alert Window Management
|
||||
|
||||
static GKMSAlertWindow *g_alertWindow = nil;
|
||||
static UIAlertController *g_currentAlert = nil;
|
||||
|
||||
static UIViewController* EnsureAlertVC() {
|
||||
if (!g_alertWindow) {
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
|
||||
g_alertWindow = [[GKMSAlertWindow alloc] initWithFrame:
|
||||
[[UIScreen mainScreen] bounds]];
|
||||
#pragma clang diagnostic pop
|
||||
g_alertWindow.rootViewController = [[UIViewController alloc] init];
|
||||
g_alertWindow.windowLevel = UIWindowLevelAlert + 1;
|
||||
g_alertWindow.backgroundColor = [UIColor clearColor];
|
||||
g_alertWindow.hidden = NO;
|
||||
}
|
||||
return g_alertWindow.rootViewController;
|
||||
}
|
||||
|
||||
static void DismissCurrentAlert() {
|
||||
UIViewController *vc = EnsureAlertVC();
|
||||
if (vc.presentedViewController) {
|
||||
__block BOOL dismissed = NO;
|
||||
[vc dismissViewControllerAnimated:NO completion:^{ dismissed = YES; }];
|
||||
NSDate *deadline = [NSDate dateWithTimeIntervalSinceNow:3.0];
|
||||
while (!dismissed &&
|
||||
[[NSDate date] compare:deadline] == NSOrderedAscending) {
|
||||
PumpRunLoop(0.05);
|
||||
}
|
||||
if (!dismissed) {
|
||||
os_log(OS_LOG_DEFAULT,
|
||||
"GakumasLocalify: Dismiss completion not fired, forcing cleanup");
|
||||
}
|
||||
}
|
||||
g_currentAlert = nil;
|
||||
}
|
||||
|
||||
static void ShowStatusAlert(NSString *title, NSString *message) {
|
||||
PerformOnMainWait(^{
|
||||
if (g_currentAlert) {
|
||||
g_currentAlert.title = title;
|
||||
g_currentAlert.message = message;
|
||||
return;
|
||||
}
|
||||
UIViewController *vc = EnsureAlertVC();
|
||||
g_currentAlert = [UIAlertController alertControllerWithTitle:title
|
||||
message:message preferredStyle:UIAlertControllerStyleAlert];
|
||||
[vc presentViewController:g_currentAlert animated:NO completion:nil];
|
||||
});
|
||||
}
|
||||
|
||||
static NSInteger ShowChoiceAlert(NSString *title, NSString *message,
|
||||
NSArray<NSString *> *buttons) {
|
||||
PerformOnMainWait(^{
|
||||
UIViewController *vc = EnsureAlertVC();
|
||||
if (vc.presentedViewController) {
|
||||
[vc dismissViewControllerAnimated:NO completion:nil];
|
||||
}
|
||||
g_currentAlert = nil;
|
||||
});
|
||||
|
||||
[NSThread sleepForTimeInterval:0.15];
|
||||
|
||||
__block NSInteger selected = -1;
|
||||
dispatch_semaphore_t sem = dispatch_semaphore_create(0);
|
||||
|
||||
PerformOnMainWait(^{
|
||||
UIViewController *vc = EnsureAlertVC();
|
||||
|
||||
UIAlertController *alert =
|
||||
[UIAlertController alertControllerWithTitle:title
|
||||
message:message
|
||||
preferredStyle:UIAlertControllerStyleAlert];
|
||||
|
||||
for (NSUInteger i = 0; i < buttons.count; i++) {
|
||||
NSInteger idx = (NSInteger)i;
|
||||
[alert addAction:[UIAlertAction actionWithTitle:buttons[i]
|
||||
style:UIAlertActionStyleDefault
|
||||
handler:^(UIAlertAction *__unused a) {
|
||||
selected = idx;
|
||||
dispatch_semaphore_signal(sem);
|
||||
}]];
|
||||
}
|
||||
|
||||
[vc presentViewController:alert animated:NO completion:nil];
|
||||
});
|
||||
|
||||
dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
|
||||
return selected;
|
||||
}
|
||||
|
||||
static void CleanupAlertWindow() {
|
||||
if (g_alertWindow) {
|
||||
if (g_alertWindow.rootViewController.presentedViewController) {
|
||||
[g_alertWindow.rootViewController
|
||||
dismissViewControllerAnimated:NO completion:nil];
|
||||
}
|
||||
g_currentAlert = nil;
|
||||
g_alertWindow.rootViewController = nil;
|
||||
g_alertWindow.hidden = YES;
|
||||
g_alertWindow = nil;
|
||||
}
|
||||
}
|
||||
|
||||
#pragma mark - Download Delegate
|
||||
|
||||
@interface GKMSDownloadDelegate : NSObject <NSURLSessionDataDelegate>
|
||||
@property (nonatomic, strong) NSMutableData *receivedData;
|
||||
@property (nonatomic, assign) int64_t expectedLength;
|
||||
@property (nonatomic, assign) BOOL finished;
|
||||
@property (nonatomic, strong) NSError *error;
|
||||
@property (nonatomic, copy) void (^onProgress)(float progress, int64_t received, int64_t total);
|
||||
@end
|
||||
|
||||
@implementation GKMSDownloadDelegate
|
||||
|
||||
- (instancetype)init {
|
||||
if ((self = [super init])) {
|
||||
_receivedData = [NSMutableData data];
|
||||
_expectedLength = NSURLResponseUnknownLength;
|
||||
_finished = NO;
|
||||
}
|
||||
return self;
|
||||
}
|
||||
|
||||
- (void)URLSession:(__unused NSURLSession *)session
|
||||
dataTask:(__unused NSURLSessionDataTask *)dataTask
|
||||
didReceiveResponse:(NSURLResponse *)response
|
||||
completionHandler:(void (^)(NSURLSessionResponseDisposition))handler {
|
||||
if ([response isKindOfClass:[NSHTTPURLResponse class]]) {
|
||||
NSInteger code = [(NSHTTPURLResponse *)response statusCode];
|
||||
if (code >= 400) {
|
||||
_error = [NSError errorWithDomain:@"GakumasLocalify" code:code
|
||||
userInfo:@{NSLocalizedDescriptionKey:
|
||||
[NSString stringWithFormat:@"HTTP %ld", (long)code]}];
|
||||
handler(NSURLSessionResponseCancel);
|
||||
return;
|
||||
}
|
||||
}
|
||||
_expectedLength = response.expectedContentLength;
|
||||
handler(NSURLSessionResponseAllow);
|
||||
}
|
||||
|
||||
- (void)URLSession:(__unused NSURLSession *)session
|
||||
dataTask:(__unused NSURLSessionDataTask *)dataTask
|
||||
didReceiveData:(NSData *)data {
|
||||
[_receivedData appendData:data];
|
||||
if (_onProgress) {
|
||||
float p = (_expectedLength > 0)
|
||||
? (float)_receivedData.length / (float)_expectedLength : -1.0f;
|
||||
int64_t recv = (int64_t)_receivedData.length;
|
||||
int64_t total = _expectedLength;
|
||||
void (^block)(float, int64_t, int64_t) = _onProgress;
|
||||
dispatch_async(dispatch_get_main_queue(), ^{
|
||||
block(p, recv, total);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
- (void)URLSession:(__unused NSURLSession *)session
|
||||
task:(__unused NSURLSessionTask *)task
|
||||
didCompleteWithError:(NSError *)error {
|
||||
if (error && !_error) _error = error;
|
||||
_finished = YES;
|
||||
}
|
||||
|
||||
@end
|
||||
|
||||
#pragma mark - Network Functions
|
||||
|
||||
static NSData* SyncDownload(NSURL *url,
|
||||
void(^progressBlock)(float, int64_t, int64_t)) {
|
||||
|
||||
GKMSDownloadDelegate *delegate = [[GKMSDownloadDelegate alloc] init];
|
||||
delegate.onProgress = progressBlock;
|
||||
|
||||
NSURLSessionConfiguration *config =
|
||||
[NSURLSessionConfiguration ephemeralSessionConfiguration];
|
||||
config.timeoutIntervalForRequest = 30;
|
||||
config.timeoutIntervalForResource = 300;
|
||||
|
||||
NSOperationQueue *delegateQueue = [[NSOperationQueue alloc] init];
|
||||
delegateQueue.maxConcurrentOperationCount = 1;
|
||||
|
||||
NSURLSession *session = [NSURLSession sessionWithConfiguration:config
|
||||
delegate:delegate delegateQueue:delegateQueue];
|
||||
|
||||
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
|
||||
[request setValue:@"GakumasLocalify-iOS" forHTTPHeaderField:@"User-Agent"];
|
||||
|
||||
os_log(OS_LOG_DEFAULT,
|
||||
"GakumasLocalify: Starting download: %{public}@", url);
|
||||
|
||||
NSURLSessionDataTask *task = [session dataTaskWithRequest:request];
|
||||
[task resume];
|
||||
|
||||
BOOL onMain = [NSThread isMainThread];
|
||||
NSTimeInterval maxWait = 60.0;
|
||||
NSDate *deadline = [NSDate dateWithTimeIntervalSinceNow:maxWait];
|
||||
while (!delegate.finished &&
|
||||
[[NSDate date] compare:deadline] == NSOrderedAscending) {
|
||||
if (onMain) PumpRunLoop(0.05);
|
||||
else [NSThread sleepForTimeInterval:0.05];
|
||||
}
|
||||
|
||||
if (!delegate.finished) {
|
||||
os_log_error(OS_LOG_DEFAULT,
|
||||
"GakumasLocalify: Download timed out (%.0fs) for %{public}@",
|
||||
maxWait, url);
|
||||
[task cancel];
|
||||
NSDate *cancelDeadline = [NSDate dateWithTimeIntervalSinceNow:5.0];
|
||||
while (!delegate.finished &&
|
||||
[[NSDate date] compare:cancelDeadline] == NSOrderedAscending) {
|
||||
if (onMain) PumpRunLoop(0.05);
|
||||
else [NSThread sleepForTimeInterval:0.05];
|
||||
}
|
||||
}
|
||||
|
||||
[session finishTasksAndInvalidate];
|
||||
|
||||
if (delegate.error) {
|
||||
NSError *e = delegate.error;
|
||||
os_log_error(OS_LOG_DEFAULT,
|
||||
"GakumasLocalify: Download error domain=%{public}@ code=%ld desc=%{public}@",
|
||||
e.domain ?: @"nil",
|
||||
(long)e.code,
|
||||
e.localizedDescription ?: @"nil");
|
||||
|
||||
NSError *underlying = e.userInfo[NSUnderlyingErrorKey];
|
||||
if (underlying) {
|
||||
os_log_error(OS_LOG_DEFAULT,
|
||||
"GakumasLocalify: Underlying error domain=%{public}@ code=%ld desc=%{public}@",
|
||||
underlying.domain ?: @"nil",
|
||||
(long)underlying.code,
|
||||
underlying.localizedDescription ?: @"nil");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
os_log(OS_LOG_DEFAULT,
|
||||
"GakumasLocalify: Download finished: %{public}@ (bytes=%lu)",
|
||||
url, (unsigned long)delegate.receivedData.length);
|
||||
}
|
||||
|
||||
if (delegate.error) {
|
||||
return nil;
|
||||
}
|
||||
return [delegate.receivedData copy];
|
||||
}
|
||||
|
||||
static id FetchJSON(NSURL *url) {
|
||||
NSData *data = SyncDownload(url, nil);
|
||||
if (!data) return nil;
|
||||
NSError *error = nil;
|
||||
id json = [NSJSONSerialization JSONObjectWithData:data options:0 error:&error];
|
||||
if (error) {
|
||||
os_log_error(OS_LOG_DEFAULT,
|
||||
"GakumasLocalify: JSON parse error: %{public}@", error);
|
||||
return nil;
|
||||
}
|
||||
return json;
|
||||
}
|
||||
|
||||
#pragma mark - ZIP Extraction
|
||||
|
||||
static BOOL ExtractZipToDirectory(NSData *zipData, NSString *destDir) {
|
||||
if (!zipData || zipData.length == 0) return NO;
|
||||
|
||||
NSString *tmpPath = [NSTemporaryDirectory()
|
||||
stringByAppendingPathComponent:[[NSUUID UUID] UUIDString]];
|
||||
tmpPath = [tmpPath stringByAppendingPathExtension:@"zip"];
|
||||
|
||||
if (![zipData writeToFile:tmpPath atomically:YES]) {
|
||||
os_log_error(OS_LOG_DEFAULT,
|
||||
"GakumasLocalify: Failed to write temp zip file");
|
||||
return NO;
|
||||
}
|
||||
|
||||
NSError *error = nil;
|
||||
BOOL success = [SSZipArchive unzipFileAtPath:tmpPath
|
||||
toDestination:destDir
|
||||
overwrite:YES
|
||||
password:nil
|
||||
error:&error];
|
||||
|
||||
[[NSFileManager defaultManager] removeItemAtPath:tmpPath error:nil];
|
||||
|
||||
if (!success) {
|
||||
os_log_error(OS_LOG_DEFAULT,
|
||||
"GakumasLocalify: SSZipArchive extraction failed: %{public}@",
|
||||
error.localizedDescription ?: @"unknown error");
|
||||
}
|
||||
return success;
|
||||
}
|
||||
|
||||
#pragma mark - Progress Display Helper
|
||||
|
||||
static void UpdateDownloadProgress(NSString *displayName,
|
||||
float progress, int64_t received, int64_t total) {
|
||||
if (!g_currentAlert) return;
|
||||
NSMutableString *msg = [NSMutableString string];
|
||||
[msg appendFormat:@"正在下载 / Downloading\n%@\n\n", displayName];
|
||||
if (progress >= 0) {
|
||||
[msg appendFormat:@"%@ %.0f%%\n%@ / %@",
|
||||
MakeProgressBar(progress), progress * 100.0f,
|
||||
FormatBytes(received), FormatBytes(total)];
|
||||
} else {
|
||||
[msg appendFormat:@"⏳ 已下载 / Downloaded: %@", FormatBytes(received)];
|
||||
}
|
||||
g_currentAlert.message = msg;
|
||||
}
|
||||
|
||||
#pragma mark - Game Version Check
|
||||
|
||||
static void CheckGameVersion(NSString *baseDir) {
|
||||
NSString *gameVersion = TrimString(
|
||||
[[NSBundle mainBundle]
|
||||
objectForInfoDictionaryKey:@"CFBundleShortVersionString"]);
|
||||
if (!gameVersion || gameVersion.length == 0) {
|
||||
os_log_error(OS_LOG_DEFAULT,
|
||||
"GakumasLocalify: Cannot read CFBundleShortVersionString");
|
||||
return;
|
||||
}
|
||||
|
||||
NSString *versionPath =
|
||||
[baseDir stringByAppendingPathComponent:@"gameVersion.txt"];
|
||||
NSString *stored = ReadFileContent(versionPath);
|
||||
|
||||
os_log(OS_LOG_DEFAULT,
|
||||
"GakumasLocalify: Game version=%{public}@, stored=%{public}@",
|
||||
gameVersion, stored ?: @"(none)");
|
||||
|
||||
if (stored && [stored isEqualToString:gameVersion]) return;
|
||||
|
||||
ShowStatusAlert(@"检查更新 / Checking for Updates",
|
||||
@"正在检查游戏版本适配...\nChecking game version compatibility...");
|
||||
|
||||
NSString *apiURL = kIl2cppRepo;
|
||||
os_log(OS_LOG_DEFAULT,
|
||||
"GakumasLocalify: Fetching il2cpp releases from %{public}@", apiURL);
|
||||
NSArray *releases = (NSArray *)FetchJSON([NSURL URLWithString:apiURL]);
|
||||
os_log(OS_LOG_DEFAULT,
|
||||
"GakumasLocalify: FetchJSON returned, releases=%{public}@",
|
||||
releases ? @"non-nil" : @"nil");
|
||||
|
||||
if (!releases || ![releases isKindOfClass:[NSArray class]]) {
|
||||
ShowChoiceAlert(
|
||||
@"检查失败 / Check Failed",
|
||||
@"无法获取版本信息，请检查网络连接。\n"
|
||||
@"Failed to fetch version info. Please check your network.",
|
||||
@[@"OK"]);
|
||||
return;
|
||||
}
|
||||
|
||||
NSDictionary *matched = nil;
|
||||
for (NSDictionary *rel in releases) {
|
||||
if ([TrimString(rel[@"tag_name"]) isEqualToString:gameVersion]) {
|
||||
matched = rel;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!matched) {
|
||||
NSInteger choice = ShowChoiceAlert(
|
||||
@"版本未适配 / Version Not Supported",
|
||||
[NSString stringWithFormat:
|
||||
@"插件暂未适配当前游戏版本 (%@)，请耐心等待更新。\n"
|
||||
@"The plugin does not yet support game version %@. "
|
||||
@"Please wait for an update.",
|
||||
gameVersion, gameVersion],
|
||||
@[@"退出游戏 / Exit Game", @"强制继续 / Continue Anyway"]);
|
||||
if (choice == 0) exit(0);
|
||||
return;
|
||||
}
|
||||
|
||||
NSURL *binURL = nil, *mapURL = nil;
|
||||
for (NSDictionary *asset in matched[@"assets"]) {
|
||||
NSString *name = asset[@"name"];
|
||||
NSString *dl = asset[@"browser_download_url"];
|
||||
if (!name || !dl) continue;
|
||||
if ([name isEqualToString:@"il2cpp.bin"])
|
||||
binURL = [NSURL URLWithString:dl];
|
||||
if ([name isEqualToString:@"il2cpp_map.json"])
|
||||
mapURL = [NSURL URLWithString:dl];
|
||||
}
|
||||
|
||||
if (!binURL || !mapURL) {
|
||||
ShowChoiceAlert(
|
||||
@"文件缺失 / Files Missing",
|
||||
@"Release 中缺少必要文件 (il2cpp.bin / il2cpp_map.json)。\n"
|
||||
@"Required files are missing from the release.",
|
||||
@[@"OK"]);
|
||||
return;
|
||||
}
|
||||
|
||||
ShowStatusAlert(@"下载中 / Downloading", @"");
|
||||
|
||||
NSData *binData = SyncDownload(binURL, ^(float p, int64_t r, int64_t t) {
|
||||
UpdateDownloadProgress(@"il2cpp.bin", p, r, t);
|
||||
});
|
||||
if (!binData) {
|
||||
ShowChoiceAlert(
|
||||
@"下载失败 / Download Failed",
|
||||
@"下载 il2cpp.bin 失败，请检查网络连接。\n"
|
||||
@"Failed to download il2cpp.bin. Please check your network.",
|
||||
@[@"OK"]);
|
||||
return;
|
||||
}
|
||||
NSString *binPath =
|
||||
[baseDir stringByAppendingPathComponent:@"il2cpp.bin"];
|
||||
[binData writeToFile:binPath atomically:YES];
|
||||
|
||||
NSData *mapData = SyncDownload(mapURL, ^(float p, int64_t r, int64_t t) {
|
||||
UpdateDownloadProgress(@"il2cpp_map.json", p, r, t);
|
||||
});
|
||||
if (!mapData) {
|
||||
ShowChoiceAlert(
|
||||
@"下载失败 / Download Failed",
|
||||
@"下载 il2cpp_map.json 失败，请检查网络连接。\n"
|
||||
@"Failed to download il2cpp_map.json. Please check your network.",
|
||||
@[@"OK"]);
|
||||
return;
|
||||
}
|
||||
NSString *mapPath =
|
||||
[baseDir stringByAppendingPathComponent:@"il2cpp_map.json"];
|
||||
[mapData writeToFile:mapPath atomically:YES];
|
||||
|
||||
WriteFileContent(versionPath, gameVersion);
|
||||
os_log(OS_LOG_DEFAULT,
|
||||
"GakumasLocalify: il2cpp files updated for version %{public}@",
|
||||
gameVersion);
|
||||
}
|
||||
|
||||
#pragma mark - Translation Update Check
|
||||
|
||||
static void CheckTranslationUpdate(NSString *baseDir) {
|
||||
ShowStatusAlert(@"检查更新 / Checking for Updates",
|
||||
@"正在检查翻译更新...\nChecking for translation updates...");
|
||||
|
||||
NSString *apiURL = kTransRepo;
|
||||
NSDictionary *latest =
|
||||
(NSDictionary *)FetchJSON([NSURL URLWithString:apiURL]);
|
||||
|
||||
if (!latest || ![latest isKindOfClass:[NSDictionary class]]) {
|
||||
os_log_error(OS_LOG_DEFAULT,
|
||||
"GakumasLocalify: Cannot fetch translation release info");
|
||||
return;
|
||||
}
|
||||
|
||||
NSString *latestTag = TrimString(latest[@"tag_name"]);
|
||||
NSString *body = latest[@"body"] ?: @"";
|
||||
if (!latestTag || latestTag.length == 0) return;
|
||||
|
||||
NSString *versionPath =
|
||||
[baseDir stringByAppendingPathComponent:@"version.txt"];
|
||||
NSString *stored = ReadFileContent(versionPath);
|
||||
|
||||
os_log(OS_LOG_DEFAULT,
|
||||
"GakumasLocalify: Trans latest=%{public}@, stored=%{public}@",
|
||||
latestTag, stored ?: @"(none)");
|
||||
|
||||
if (stored && [stored isEqualToString:latestTag]) return;
|
||||
|
||||
NSString *currentDisplay = stored
|
||||
? stored : @"未安装 / Not installed";
|
||||
NSString *msg = [NSString stringWithFormat:
|
||||
@"发现翻译文件更新 / Translation update available\n\n"
|
||||
@"当前版本 / Current: %@\n"
|
||||
@"最新版本 / Latest: %@\n\n%@",
|
||||
currentDisplay, latestTag, body];
|
||||
|
||||
NSInteger choice = ShowChoiceAlert(
|
||||
@"翻译更新 / Translation Update", msg,
|
||||
@[@"更新 / Update", @"跳过 / Skip"]);
|
||||
if (choice != 0) return;
|
||||
|
||||
NSURL *zipURL = nil;
|
||||
for (NSDictionary *asset in latest[@"assets"]) {
|
||||
if ([asset[@"name"] hasSuffix:@".zip"]) {
|
||||
zipURL = [NSURL URLWithString:asset[@"browser_download_url"]];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!zipURL) {
|
||||
ShowChoiceAlert(
|
||||
@"更新失败 / Update Failed",
|
||||
@"未找到更新文件。\nUpdate package not found in release.",
|
||||
@[@"OK"]);
|
||||
return;
|
||||
}
|
||||
|
||||
ShowStatusAlert(@"下载更新 / Downloading Update", @"");
|
||||
NSData *zipData = SyncDownload(zipURL, ^(float p, int64_t r, int64_t t) {
|
||||
UpdateDownloadProgress(@"translation update", p, r, t);
|
||||
});
|
||||
|
||||
if (!zipData) {
|
||||
ShowChoiceAlert(
|
||||
@"下载失败 / Download Failed",
|
||||
@"下载翻译更新失败，请检查网络连接。\n"
|
||||
@"Failed to download translation update. Please check your network.",
|
||||
@[@"OK"]);
|
||||
return;
|
||||
}
|
||||
|
||||
ShowStatusAlert(@"解压中 / Extracting",
|
||||
@"正在解压翻译文件...\nExtracting translation files...");
|
||||
PumpRunLoop(0.1);
|
||||
|
||||
if (!ExtractZipToDirectory(zipData, baseDir)) {
|
||||
ShowChoiceAlert(
|
||||
@"解压失败 / Extraction Failed",
|
||||
@"解压翻译文件失败。\nFailed to extract translation files.",
|
||||
@[@"OK"]);
|
||||
return;
|
||||
}
|
||||
|
||||
os_log(OS_LOG_DEFAULT,
|
||||
"GakumasLocalify: Translation updated to %{public}@", latestTag);
|
||||
}
|
||||
|
||||
#pragma mark - Public API
|
||||
|
||||
void CheckForUpdates(const std::string& baseDir) {
|
||||
@try {
|
||||
NSString *dir = [NSString stringWithUTF8String:baseDir.c_str()];
|
||||
|
||||
[[NSFileManager defaultManager] createDirectoryAtPath:dir
|
||||
withIntermediateDirectories:YES attributes:nil error:nil];
|
||||
|
||||
ShowStatusAlert(@"检查更新 / Checking for Updates",
|
||||
@"请稍候...\nPlease wait...");
|
||||
|
||||
if (kIl2cppRepo.length > 0) {
|
||||
CheckGameVersion(dir);
|
||||
} else {
|
||||
os_log(OS_LOG_DEFAULT,
|
||||
"GakumasLocalify: il2cpp repo not configured, skipping");
|
||||
}
|
||||
|
||||
if (kTransRepo.length > 0) {
|
||||
CheckTranslationUpdate(dir);
|
||||
} else {
|
||||
os_log(OS_LOG_DEFAULT,
|
||||
"GakumasLocalify: Translation repo not configured, skipping");
|
||||
}
|
||||
|
||||
PerformOnMainWait(^{ CleanupAlertWindow(); });
|
||||
g_updateCheckDone.store(true);
|
||||
os_log(OS_LOG_DEFAULT, "GakumasLocalify: Update check done");
|
||||
} @catch (NSException *exception) {
|
||||
os_log_error(OS_LOG_DEFAULT,
|
||||
"GakumasLocalify: Update check exception: %{public}@", exception);
|
||||
PerformOnMainWait(^{ CleanupAlertWindow(); });
|
||||
g_updateCheckDone.store(true);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
#pragma once
|
||||
|
||||
#include <cstdio>
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
|
||||
#include <dlfcn.h>
|
||||
#include <os/log.h>
|
||||
|
||||
#define GKMS_IOS
|
||||
// #define GKMS_WINDOWS
|
||||
|
||||
#define ANDROID_LOG_VERBOSE 2
|
||||
#define ANDROID_LOG_DEBUG 3
|
||||
#define ANDROID_LOG_INFO 4
|
||||
#define ANDROID_LOG_ERROR 6
|
||||
|
||||
#define LogMinVersion ANDROID_LOG_DEBUG
|
||||
|
||||
#define PLUGIN_VERSION "3.2.0 Beta 1"
|
||||
|
||||
typedef enum MH_STATUS {
|
||||
MH_OK = 0,
|
||||
MH_ERROR_ALREADY_INITIALIZED,
|
||||
MH_ERROR_NOT_INITIALIZED,
|
||||
MH_ERROR_MEMORY_ALLOC,
|
||||
MH_ERROR_UNSUPPORTED_FUNCTION
|
||||
} MH_STATUS;
|
||||
|
||||
static inline const char* MH_StatusToString(MH_STATUS status) {
|
||||
switch (status) {
|
||||
case MH_OK: return "MH_OK";
|
||||
case MH_ERROR_ALREADY_INITIALIZED: return "MH_ERROR_ALREADY_INITIALIZED";
|
||||
case MH_ERROR_NOT_INITIALIZED: return "MH_ERROR_NOT_INITIALIZED";
|
||||
case MH_ERROR_MEMORY_ALLOC: return "MH_ERROR_MEMORY_ALLOC";
|
||||
case MH_ERROR_UNSUPPORTED_FUNCTION: return "MH_ERROR_UNSUPPORTED_FUNCTION";
|
||||
default: return "MH_UNKNOWN";
|
||||
}
|
||||
}
|
||||
|
||||
static inline void __android_log_write(int prio, const char* tag, const char* msg) {
|
||||
if (prio < LogMinVersion) return;
|
||||
|
||||
os_log_type_t osType;
|
||||
if (prio >= ANDROID_LOG_ERROR) osType = OS_LOG_TYPE_ERROR;
|
||||
else if (prio >= ANDROID_LOG_INFO) osType = OS_LOG_TYPE_DEFAULT;
|
||||
else if (prio >= ANDROID_LOG_DEBUG) osType = OS_LOG_TYPE_DEFAULT;
|
||||
else osType = OS_LOG_TYPE_DEFAULT;
|
||||
|
||||
os_log_with_type(OS_LOG_DEFAULT, osType,
|
||||
"%{public}s: %{public}s",
|
||||
tag ? tag : "log", msg ? msg : "");
|
||||
}
|
||||
|
||||
#define ADD_HOOK(name, addr) \
|
||||
do { \
|
||||
auto _hook_addr_ = reinterpret_cast<void*>(addr); \
|
||||
name##_Addr = reinterpret_cast<name##_Type>(_hook_addr_); \
|
||||
if (_hook_addr_) { \
|
||||
auto stub = hookInstaller->InstallHook(_hook_addr_, \
|
||||
reinterpret_cast<void*>(name##_Hook), \
|
||||
reinterpret_cast<void**>(&name##_Orig)); \
|
||||
if (stub) { \
|
||||
Log::ErrorFmt("ADD_HOOK: %s at %p failed: %s", #name, _hook_addr_, \
|
||||
MH_StatusToString(static_cast<MH_STATUS>(reinterpret_cast<intptr_t>(stub)))); \
|
||||
} \
|
||||
else { \
|
||||
hookedStubs.emplace(stub); \
|
||||
GakumasLocal::Log::InfoFmt("ADD_HOOK: %s at %p", #name, _hook_addr_); \
|
||||
} \
|
||||
} \
|
||||
else GakumasLocal::Log::ErrorFmt("Hook failed: %s is NULL", #name); /*if (Config::lazyInit) UnityResolveProgress::classProgress.current++;*/ \
|
||||
} while (0)
|
||||
Loading…
Reference in New Issue