Merge remote-tracking branch 'origin/master' into net-rollback
This commit is contained in:
commit
dc5acd24b2
|
@ -0,0 +1,33 @@
|
|||
# Prepare source texts & upload them to Crowdin
|
||||
|
||||
name: Crowdin Source Texts Upload
|
||||
|
||||
# on change to the English texts
|
||||
on:
|
||||
push:
|
||||
branches:
|
||||
- master
|
||||
paths:
|
||||
- 'shell/libretro/libretro_core_options.h'
|
||||
|
||||
jobs:
|
||||
upload_source_file:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Setup Java JDK
|
||||
uses: actions/setup-java@v1
|
||||
with:
|
||||
java-version: 1.8
|
||||
|
||||
- name: Setup Python
|
||||
uses: actions/setup-python@v2
|
||||
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v2
|
||||
|
||||
- name: Upload Source
|
||||
shell: bash
|
||||
env:
|
||||
CROWDIN_API_KEY: ${{ secrets.CROWDIN_API_KEY }}
|
||||
run: |
|
||||
python3 intl/upload_workflow.py $CROWDIN_API_KEY "flyinghead-flycast" "shell/libretro/libretro_core_options.h"
|
|
@ -0,0 +1,46 @@
|
|||
# Download translations form Crowdin & Recreate libretro_core_options_intl.h
|
||||
|
||||
name: Crowdin Translation Integration
|
||||
|
||||
on:
|
||||
schedule:
|
||||
# please choose a random time & weekday to avoid all repos synching at the same time
|
||||
- cron: '15 22 * * 5' # Fridays at 10:15 PM, UTC
|
||||
|
||||
jobs:
|
||||
create_intl_file:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Setup Java JDK
|
||||
uses: actions/setup-java@v1
|
||||
with:
|
||||
java-version: 1.8
|
||||
|
||||
- name: Setup Python
|
||||
uses: actions/setup-python@v2
|
||||
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v2
|
||||
with:
|
||||
persist-credentials: false # otherwise, the token used is the GITHUB_TOKEN, instead of your personal access token.
|
||||
fetch-depth: 0 # otherwise, there would be errors pushing refs to the destination repository.
|
||||
|
||||
- name: Create intl file
|
||||
shell: bash
|
||||
env:
|
||||
CROWDIN_API_KEY: ${{ secrets.CROWDIN_API_KEY }}
|
||||
run: |
|
||||
python3 intl/download_workflow.py $CROWDIN_API_KEY "flyinghead-flycast" "shell/libretro/libretro_core_options_intl.h"
|
||||
|
||||
- name: Commit files
|
||||
run: |
|
||||
git config --local user.email "github-actions@github.com"
|
||||
git config --local user.name "github-actions[bot]"
|
||||
git add intl/*_workflow.py "shell/libretro/libretro_core_options_intl.h"
|
||||
git commit -m "Fetch translations & Recreate libretro_core_options_intl.h"
|
||||
|
||||
- name: GitHub Push
|
||||
uses: ad-m/github-push-action@v0.6.0
|
||||
with:
|
||||
github_token: ${{ secrets.GITHUB_TOKEN }}
|
||||
branch: ${{ github.ref }}
|
|
@ -0,0 +1,118 @@
|
|||
# DESCRIPTION: GitLab CI/CD for libRetro (NOT FOR GitLab-proper)
|
||||
|
||||
##############################################################################
|
||||
################################# BOILERPLATE ################################
|
||||
##############################################################################
|
||||
|
||||
# Core definitions
|
||||
.core-defs:
|
||||
variables:
|
||||
GIT_SUBMODULE_STRATEGY: recursive
|
||||
CORENAME: flycast
|
||||
CORE_ARGS: -DLIBRETRO=ON -DCMAKE_BUILD_TYPE=Release
|
||||
|
||||
.core-defs-linux:
|
||||
extends: .core-defs
|
||||
variables:
|
||||
CORE_ARGS: -DLIBRETRO=ON -DCMAKE_POSITION_INDEPENDENT_CODE=TRUE -DCMAKE_BUILD_TYPE=Release
|
||||
|
||||
.core-defs-osx-x64:
|
||||
extends: .core-defs
|
||||
variables:
|
||||
CORE_ARGS: -DLIBRETRO=ON -G Xcode -DCMAKE_BUILD_TYPE=Release
|
||||
EXTRA_PATH: Release
|
||||
|
||||
.core-defs-android:
|
||||
extends: .core-defs
|
||||
script:
|
||||
- cmake $CORE_ARGS -DANDROID_PLATFORM=android-$API_LEVEL -DCMAKE_TOOLCHAIN_FILE=$NDK_ROOT/build/cmake/android.toolchain.cmake -DANDROID_STL=c++_static -DANDROID_ABI=$ANDROID_ABI -DANDROID_ARM_MODE=arm "$CMAKE_SOURCE_ROOT" -B$BUILD_DIR
|
||||
- cmake --build $BUILD_DIR --target ${CORENAME}_libretro --config Release -- -j $NUMPROC
|
||||
- mv $BUILD_DIR/${CORENAME}_libretro.so $LIBNAME
|
||||
- if [ $STRIP_CORE_LIB -eq 1 ]; then $NDK_ROOT/toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-strip $LIBNAME; fi
|
||||
variables:
|
||||
API_LEVEL: 18
|
||||
|
||||
# Inclusion templates, required for the build to work
|
||||
include:
|
||||
################################## DESKTOPS ################################
|
||||
# Windows
|
||||
- project: 'libretro-infrastructure/ci-templates'
|
||||
file: '/windows-cmake-mingw.yml'
|
||||
|
||||
# MacOS
|
||||
- project: 'libretro-infrastructure/ci-templates'
|
||||
file: 'osx-cmake-x86.yml'
|
||||
|
||||
# Linux
|
||||
- project: 'libretro-infrastructure/ci-templates'
|
||||
file: '/linux-cmake.yml'
|
||||
|
||||
################################## CELLULAR ################################
|
||||
# Android
|
||||
- project: 'libretro-infrastructure/ci-templates'
|
||||
file: '/android-cmake.yml'
|
||||
|
||||
# Stages for building
|
||||
stages:
|
||||
- build-prepare
|
||||
- build-shared
|
||||
|
||||
##############################################################################
|
||||
#################################### STAGES ##################################
|
||||
##############################################################################
|
||||
#
|
||||
################################### DESKTOPS #################################
|
||||
# Windows 64-bit
|
||||
libretro-build-windows-x64:
|
||||
extends:
|
||||
- .libretro-windows-cmake-x86_64
|
||||
- .core-defs
|
||||
|
||||
# Windows 32-bit
|
||||
libretro-build-windows-i686:
|
||||
extends:
|
||||
- .libretro-windows-cmake-x86
|
||||
- .core-defs
|
||||
|
||||
# Linux 64-bit
|
||||
libretro-build-linux-x64:
|
||||
extends:
|
||||
- .libretro-linux-cmake-x86_64
|
||||
- .core-defs-linux
|
||||
|
||||
# Linux 32-bit
|
||||
libretro-build-linux-i686:
|
||||
extends:
|
||||
- .libretro-linux-cmake-x86
|
||||
- .core-defs-linux
|
||||
|
||||
# MacOS 64-bit
|
||||
libretro-build-osx-x64:
|
||||
extends:
|
||||
- .libretro-osx-cmake-x86
|
||||
- .core-defs-osx-x64
|
||||
|
||||
################################### CELLULAR #################################
|
||||
# Android ARMv7a
|
||||
android-armeabi-v7a:
|
||||
extends:
|
||||
- .libretro-android-cmake-armeabi-v7a
|
||||
- .core-defs-android
|
||||
|
||||
# Android ARMv8a
|
||||
android-arm64-v8a:
|
||||
extends:
|
||||
- .libretro-android-cmake-arm64-v8a
|
||||
- .core-defs-android
|
||||
|
||||
# Android 64-bit x86
|
||||
android-x86_64:
|
||||
extends:
|
||||
- .libretro-android-cmake-x86_64
|
||||
- .core-defs-android
|
||||
|
||||
# Android 32-bit x86
|
||||
android-x86:
|
||||
extends:
|
||||
- .libretro-android-cmake-x86
|
||||
- .core-defs-android
|
|
@ -31,7 +31,13 @@ if(APPLE)
|
|||
endif()
|
||||
endif()
|
||||
|
||||
project(flycast)
|
||||
if(LIBRETRO)
|
||||
project(flycast_libretro)
|
||||
else()
|
||||
project(flycast)
|
||||
endif()
|
||||
|
||||
include(GNUInstallDirs)
|
||||
|
||||
if(ENABLE_CTEST)
|
||||
include(CTest)
|
||||
|
@ -223,7 +229,7 @@ target_link_libraries(${PROJECT_NAME} PRIVATE glm::glm)
|
|||
|
||||
if(USE_VULKAN)
|
||||
option(BUILD_EXTERNAL "Build external dependencies in /External" OFF)
|
||||
add_subdirectory(core/deps/glslang)
|
||||
add_subdirectory(core/deps/glslang EXCLUDE_FROM_ALL)
|
||||
target_link_libraries(${PROJECT_NAME} PRIVATE SPIRV)
|
||||
endif()
|
||||
|
||||
|
@ -364,6 +370,11 @@ if(NINTENDO_SWITCH AND USE_GLES)
|
|||
endif()
|
||||
|
||||
if(UNIX AND NOT APPLE AND NOT ANDROID)
|
||||
add_definitions(
|
||||
-DFLYCAST_DATADIR="${CMAKE_INSTALL_FULL_DATADIR}/${PROJECT_NAME}/"
|
||||
-DFLYCAST_SYSCONFDIR="${CMAKE_INSTALL_FULL_SYSCONFDIR}/${PROJECT_NAME}/"
|
||||
)
|
||||
|
||||
if(USE_GLES2)
|
||||
target_compile_definitions(${PROJECT_NAME} PRIVATE GLES GLES2)
|
||||
target_link_libraries(${PROJECT_NAME} PRIVATE GLESv2)
|
||||
|
@ -1155,7 +1166,7 @@ if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64.*|AARCH64.*|arm64.*)" OR CMAKE_OSX_
|
|||
set(KNOWN_ARCHITECTURE_DETECTED ON)
|
||||
endif()
|
||||
if(CMAKE_SYSTEM_PROCESSOR MATCHES "i686.*|i386.*|x86.*|amd64.*|x86_64.*|AMD64.*" OR CMAKE_OSX_ARCHITECTURES MATCHES "x86_64")
|
||||
add_subdirectory(core/deps/xbyak)
|
||||
add_subdirectory(core/deps/xbyak EXCLUDE_FROM_ALL)
|
||||
target_link_libraries(${PROJECT_NAME} PRIVATE xbyak::xbyak)
|
||||
if(CMAKE_SIZEOF_VOID_P EQUAL 4)
|
||||
target_sources(${PROJECT_NAME} PRIVATE
|
||||
|
@ -1425,3 +1436,29 @@ if(NINTENDO_SWITCH)
|
|||
nx_create_nro(flycast NACP flycast.nacp ICON "${CMAKE_SOURCE_DIR}/shell/switch/flycast.jpeg")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if(UNIX AND NOT APPLE AND NOT ANDROID)
|
||||
install(TARGETS ${PROJECT_NAME}
|
||||
DESTINATION "${CMAKE_INSTALL_BINDIR}"
|
||||
)
|
||||
install(FILES shell/linux/man/${PROJECT_NAME}.1
|
||||
DESTINATION "${CMAKE_INSTALL_MANDIR}/man1"
|
||||
)
|
||||
install(FILES shell/linux/${PROJECT_NAME}.desktop
|
||||
DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/applications"
|
||||
)
|
||||
install(FILES shell/linux/${PROJECT_NAME}.png
|
||||
DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/pixmaps"
|
||||
)
|
||||
install(FILES shell/linux/org.${PROJECT_NAME}.Flycast.metainfo.xml
|
||||
DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/metainfo"
|
||||
)
|
||||
foreach(size 16 32 64 128 256 512)
|
||||
install(FILES
|
||||
shell/apple/emulator-osx/emulator-osx/Images.xcassets/AppIcon.appiconset/Icon-${size}.png
|
||||
DESTINATION
|
||||
"${CMAKE_INSTALL_DATAROOTDIR}/icons/hicolor/${size}x${size}/apps"
|
||||
RENAME ${PROJECT_NAME}.png
|
||||
)
|
||||
endforeach()
|
||||
endif()
|
||||
|
|
|
@ -138,7 +138,7 @@ void InstallAlternateStackLocked() {
|
|||
// SIGSTKSZ may be too small to prevent the signal handlers from overrunning
|
||||
// the alternative stack. Ensure that the size of the alternative stack is
|
||||
// large enough.
|
||||
static const unsigned kSigStackSize = std::max(16384, SIGSTKSZ);
|
||||
static const unsigned kSigStackSize = std::max<size_t>(16384, SIGSTKSZ);
|
||||
|
||||
// Only set an alternative stack if there isn't already one, or if the current
|
||||
// one is too small.
|
||||
|
|
|
@ -2978,15 +2978,7 @@ static bool glsm_state_ctx_init(glsm_ctx_params_t *params)
|
|||
return false;
|
||||
|
||||
#ifdef HAVE_OPENGLES
|
||||
#if defined(HAVE_OPENGLES_3_1)
|
||||
hw_render.context_type = RETRO_HW_CONTEXT_OPENGLES_VERSION;
|
||||
hw_render.version_major = 3;
|
||||
hw_render.version_minor = 1;
|
||||
#elif defined(HAVE_OPENGLES3)
|
||||
hw_render.context_type = RETRO_HW_CONTEXT_OPENGLES3;
|
||||
#else
|
||||
hw_render.context_type = RETRO_HW_CONTEXT_OPENGLES2;
|
||||
#endif
|
||||
#else
|
||||
hw_render.context_type = RETRO_HW_CONTEXT_OPENGL;
|
||||
if (params->context_type != RETRO_HW_CONTEXT_NONE)
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -458,9 +458,10 @@ void _vmem_init_mappings()
|
|||
{
|
||||
_vmem_term_mappings();
|
||||
// Fallback to statically allocated buffers, this results in slow-ops being generated.
|
||||
if (vmemstatus == MemTypeError) {
|
||||
if (vmemstatus == MemTypeError)
|
||||
{
|
||||
WARN_LOG(VMEM, "Warning! nvmem is DISABLED (due to failure or not being built-in");
|
||||
virt_ram_base = 0;
|
||||
virt_ram_base = nullptr;
|
||||
|
||||
// Allocate it all and initialize it.
|
||||
p_sh4rcb = (Sh4RCB*)malloc_pages(sizeof(Sh4RCB));
|
||||
|
|
|
@ -1198,9 +1198,9 @@ Game Games[] =
|
|||
},
|
||||
// Death Crimson OX (JPN, USA, EXP, KOR, AUS)
|
||||
{
|
||||
"deathcox",
|
||||
NULL,
|
||||
"Death Crimson OX (Rev A)",
|
||||
"deathcoxj",
|
||||
"deathcox",
|
||||
"Death Crimson OX (Japan, Rev A)",
|
||||
0x05800000,
|
||||
0x000b64d0,
|
||||
NULL,
|
||||
|
@ -1224,11 +1224,39 @@ Game Games[] =
|
|||
NULL,
|
||||
&trigger_inputs
|
||||
},
|
||||
// Death Crimson OX (USA)
|
||||
{
|
||||
"deathcox",
|
||||
NULL,
|
||||
"Death Crimson OX (USA)",
|
||||
0x05800000,
|
||||
0x000b64d0,
|
||||
NULL,
|
||||
M2,
|
||||
REGION_AUSTRALIA,
|
||||
ROT0,
|
||||
{
|
||||
{ "dcox_us.ic22", 0x0000000, 0x0400000, 0x0580a27e },
|
||||
{ "mpr-23514.ic1", 0x0800000, 0x0800000, 0x1f2b090e },
|
||||
{ "mpr-23515.ic2", 0x1000000, 0x0800000, 0xdc8557eb },
|
||||
{ "mpr-23516.ic3", 0x1800000, 0x0800000, 0x94494cbb },
|
||||
{ "mpr-23517.ic4", 0x2000000, 0x0800000, 0x69ba6a41 },
|
||||
{ "mpr-23518.ic5", 0x2800000, 0x0800000, 0x49882766 },
|
||||
{ "mpr-23519.ic6", 0x3000000, 0x0800000, 0xcdc82805 },
|
||||
{ "mpr-23520.ic7", 0x3800000, 0x0800000, 0x1a268360 },
|
||||
{ "mpr-23521.ic8", 0x4000000, 0x0800000, 0xcf8674b8 },
|
||||
{ "mpr-23522.ic9", 0x4800000, 0x0800000, 0x7ae6716e },
|
||||
{ "mpr-23523.ic10",0x5000000, 0x0800000, 0xc91efb67 },
|
||||
|
||||
},
|
||||
NULL,
|
||||
&trigger_inputs
|
||||
},
|
||||
// Death Crimson OX
|
||||
{
|
||||
"deathcoxo",
|
||||
"deathcox",
|
||||
"Death Crimson OX",
|
||||
"Death Crimson OX (Japan)",
|
||||
0x05800000,
|
||||
0x000b64d0,
|
||||
NULL,
|
||||
|
@ -3981,7 +4009,7 @@ Game Games[] =
|
|||
"wrungp",
|
||||
"Wave Runner GP (USA, Rev A)",
|
||||
0x06800000,
|
||||
0xffffffff, // not populated
|
||||
0x284ae7c3,
|
||||
NULL,
|
||||
M2,
|
||||
REGION_AUSTRALIA,
|
||||
|
|
|
@ -266,6 +266,10 @@ std::vector<std::string> find_system_config_dirs()
|
|||
}
|
||||
else
|
||||
{
|
||||
#ifdef FLYCAST_SYSCONFDIR
|
||||
const std::string config_dir (FLYCAST_SYSCONFDIR);
|
||||
dirs.push_back(config_dir);
|
||||
#endif
|
||||
dirs.push_back("/etc/flycast/"); // This isn't part of the XDG spec, but much more common than /etc/xdg/
|
||||
dirs.push_back("/etc/xdg/flycast/");
|
||||
}
|
||||
|
@ -325,6 +329,10 @@ std::vector<std::string> find_system_data_dirs()
|
|||
}
|
||||
else
|
||||
{
|
||||
#ifdef FLYCAST_DATADIR
|
||||
const std::string data_dir (FLYCAST_DATADIR);
|
||||
dirs.push_back(data_dir);
|
||||
#endif
|
||||
dirs.push_back("/usr/local/share/flycast/");
|
||||
dirs.push_back("/usr/share/flycast/");
|
||||
dirs.push_back("/usr/local/share/reicast/");
|
||||
|
|
|
@ -17,19 +17,11 @@
|
|||
#include "stdclass.h"
|
||||
|
||||
#ifndef MAP_NOSYNC
|
||||
#define MAP_NOSYNC 0 //missing from linux :/ -- could be the cause of android slowness ?
|
||||
#define MAP_NOSYNC 0
|
||||
#endif
|
||||
|
||||
#ifdef __ANDROID__
|
||||
#include <linux/ashmem.h>
|
||||
#ifndef ASHMEM_DEVICE
|
||||
#define ASHMEM_DEVICE "/dev/ashmem"
|
||||
#undef PAGE_MASK
|
||||
#define PAGE_MASK (PAGE_SIZE-1)
|
||||
#else
|
||||
#define PAGE_SIZE 4096
|
||||
#define PAGE_MASK (PAGE_SIZE-1)
|
||||
#endif
|
||||
#include <linux/ashmem.h>
|
||||
|
||||
// Only available in SDK 26+. Required in SDK 29+ (android 10)
|
||||
extern "C" int __attribute__((weak)) ASharedMemory_create(const char*, size_t);
|
||||
|
@ -37,16 +29,22 @@ extern "C" int __attribute__((weak)) ASharedMemory_create(const char*, size_t);
|
|||
// Android specific ashmem-device stuff for creating shared memory regions
|
||||
int ashmem_create_region(const char *name, size_t size)
|
||||
{
|
||||
int fd = -1;
|
||||
if (ASharedMemory_create != nullptr)
|
||||
return ASharedMemory_create(name, size);
|
||||
{
|
||||
fd = ASharedMemory_create(name, size);
|
||||
if (fd < 0)
|
||||
WARN_LOG(VMEM, "ASharedMemory_create failed: errno %d", errno);
|
||||
}
|
||||
|
||||
int fd = open(ASHMEM_DEVICE, O_RDWR);
|
||||
if (fd < 0)
|
||||
return -1;
|
||||
|
||||
if (ioctl(fd, ASHMEM_SET_SIZE, size) < 0) {
|
||||
close(fd);
|
||||
return -1;
|
||||
{
|
||||
fd = open("/dev/ashmem", O_RDWR);
|
||||
if (fd >= 0 && ioctl(fd, ASHMEM_SET_SIZE, size) < 0)
|
||||
{
|
||||
close(fd);
|
||||
fd = -1;
|
||||
}
|
||||
}
|
||||
|
||||
return fd;
|
||||
|
@ -133,17 +131,18 @@ static int allocate_shared_filemem(unsigned size) {
|
|||
fd = open(path.c_str(), O_CREAT|O_RDWR|O_TRUNC, S_IRWXU|S_IRWXG|S_IRWXO);
|
||||
unlink(path.c_str());
|
||||
}
|
||||
// If we can't open the file, fallback to slow mem.
|
||||
if (fd < 0)
|
||||
return -1;
|
||||
|
||||
// Finally make the file as big as we need!
|
||||
if (ftruncate(fd, size)) {
|
||||
// Can't get as much memory as needed, fallback.
|
||||
close(fd);
|
||||
return -1;
|
||||
if (fd >= 0)
|
||||
{
|
||||
// Finally make the file as big as we need!
|
||||
if (ftruncate(fd, size)) {
|
||||
// Can't get as much memory as needed, fallback.
|
||||
close(fd);
|
||||
fd = -1;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
if (fd < 0)
|
||||
WARN_LOG(VMEM, "Virtual memory file allocation failed: errno %d", errno);
|
||||
|
||||
return fd;
|
||||
}
|
||||
|
@ -199,9 +198,18 @@ VMemType vmem_platform_init(void **vmem_base_addr, void **sh4rcb_addr) {
|
|||
}
|
||||
|
||||
// Just tries to wipe as much as possible in the relevant area.
|
||||
void vmem_platform_destroy() {
|
||||
if (reserved_base != NULL)
|
||||
void vmem_platform_destroy()
|
||||
{
|
||||
if (reserved_base != nullptr)
|
||||
{
|
||||
mem_region_release(reserved_base, reserved_size);
|
||||
reserved_base = nullptr;
|
||||
}
|
||||
if (vmem_fd >= 0)
|
||||
{
|
||||
close(vmem_fd);
|
||||
vmem_fd = -1;
|
||||
}
|
||||
}
|
||||
|
||||
// Resets a chunk of memory by deleting its data and setting its protection back.
|
||||
|
|
|
@ -22,7 +22,7 @@
|
|||
#ifdef _WIN64
|
||||
#include "oslib/oslib.h"
|
||||
#include <windows.h>
|
||||
#include <DbgHelp.h>
|
||||
#include <dbghelp.h>
|
||||
#include <algorithm>
|
||||
|
||||
#define UWOP_PUSH_NONVOL 0
|
||||
|
|
|
@ -0,0 +1,4 @@
|
|||
__pycache__
|
||||
crowdin-cli.jar
|
||||
*.h
|
||||
*.json
|
|
@ -0,0 +1,70 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
import os
|
||||
import glob
|
||||
import random as r
|
||||
|
||||
# -------------------- MAIN -------------------- #
|
||||
|
||||
if __name__ == '__main__':
|
||||
DIR_PATH = os.path.dirname(os.path.realpath(__file__))
|
||||
if os.path.basename(DIR_PATH) != "intl":
|
||||
raise RuntimeError("Script is not in intl folder!")
|
||||
|
||||
BASE_PATH = os.path.dirname(DIR_PATH)
|
||||
WORKFLOW_PATH = os.path.join(BASE_PATH, ".github", "workflows")
|
||||
PREP_WF = os.path.join(WORKFLOW_PATH, "crowdin_prep.yml")
|
||||
TRANSLATE_WF = os.path.join(WORKFLOW_PATH, "crowdin_translate.yml")
|
||||
CORE_NAME = os.path.basename(BASE_PATH)
|
||||
CORE_OP_FILE = os.path.join(BASE_PATH, "**", "libretro_core_options.h")
|
||||
|
||||
core_options_hits = glob.glob(CORE_OP_FILE, recursive=True)
|
||||
|
||||
if len(core_options_hits) == 0:
|
||||
raise RuntimeError("libretro_core_options.h not found!")
|
||||
elif len(core_options_hits) > 1:
|
||||
print("More than one libretro_core_options.h file found:\n\n")
|
||||
for i, file in enumerate(core_options_hits):
|
||||
print(f"{i} {file}\n")
|
||||
|
||||
while True:
|
||||
user_choice = input("Please choose one ('q' will exit): ")
|
||||
if user_choice == 'q':
|
||||
exit(0)
|
||||
elif user_choice.isdigit():
|
||||
core_op_file = core_options_hits[int(user_choice)]
|
||||
break
|
||||
else:
|
||||
print("Please make a valid choice!\n\n")
|
||||
else:
|
||||
core_op_file = core_options_hits[0]
|
||||
|
||||
core_intl_file = os.path.join(os.path.dirname(core_op_file.replace(BASE_PATH, ''))[1:],
|
||||
'libretro_core_options_intl.h')
|
||||
core_op_file = os.path.join(os.path.dirname(core_op_file.replace(BASE_PATH, ''))[1:],
|
||||
'libretro_core_options.h')
|
||||
minutes = r.randrange(0, 59, 5)
|
||||
hour = r.randrange(0, 23)
|
||||
|
||||
with open(PREP_WF, 'r') as wf_file:
|
||||
prep_txt = wf_file.read()
|
||||
|
||||
prep_txt = prep_txt.replace("<CORE_NAME>", CORE_NAME)
|
||||
prep_txt = prep_txt.replace("<PATH/TO>/libretro_core_options.h",
|
||||
core_op_file)
|
||||
with open(PREP_WF, 'w') as wf_file:
|
||||
wf_file.write(prep_txt)
|
||||
|
||||
|
||||
with open(TRANSLATE_WF, 'r') as wf_file:
|
||||
translate_txt = wf_file.read()
|
||||
|
||||
translate_txt = translate_txt.replace('<0-59>', f"{minutes}")
|
||||
translate_txt = translate_txt.replace('<0-23>', f"{hour}")
|
||||
translate_txt = translate_txt.replace('# Fridays at , UTC',
|
||||
f"# Fridays at {hour%12}:{minutes} {'AM' if hour < 12 else 'PM'}, UTC")
|
||||
translate_txt = translate_txt.replace("<CORE_NAME>", CORE_NAME)
|
||||
translate_txt = translate_txt.replace('<PATH/TO>/libretro_core_options_intl.h',
|
||||
core_intl_file)
|
||||
with open(TRANSLATE_WF, 'w') as wf_file:
|
||||
wf_file.write(translate_txt)
|
|
@ -0,0 +1,95 @@
|
|||
import re
|
||||
|
||||
# 0: full struct; 1: up to & including first []; 2: content between first {}
|
||||
p_struct = re.compile(r'(struct\s*[a-zA-Z0-9_\s]+\[])\s*'
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+)\s*)*'
|
||||
r'=\s*' # =
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+)\s*)*'
|
||||
r'{((?:.|[\r\n])*?)\{\s*NULL,\s*NULL,\s*NULL\s*(?:.|[\r\n])*?},?(?:.|[\r\n])*?};') # captures full struct, it's beginning and it's content
|
||||
# 0: type name[]; 1: type; 2: name
|
||||
p_type_name = re.compile(r'(retro_core_option_[a-zA-Z0-9_]+)\s*'
|
||||
r'(option_cats([a-z_]{0,8})|option_defs([a-z_]{0,8}))\s*\[]')
|
||||
# 0: full option; 1: key; 2: description; 3: additional info; 4: key/value pairs
|
||||
p_option = re.compile(r'{\s*' # opening braces
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r'(\".*?\"|' # key start; group 1
|
||||
r'[a-zA-Z0-9_]+\s*\((?:.|[\r\n])*?\)|'
|
||||
r'[a-zA-Z0-9_]+\s*\[(?:.|[\r\n])*?]|'
|
||||
r'[a-zA-Z0-9_]+\s*\".*?\")\s*' # key end
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r',\s*' # comma
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r'(\".*?\")\s*' # description; group 2
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r',\s*' # comma
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r'((?:' # group 3
|
||||
r'(?:NULL|\"(?:.|[\r\n])*?\")\s*' # description in category, info, info in category, category
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r',?\s*' # comma
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r')+)'
|
||||
r'(?:' # defs only start
|
||||
r'{\s*' # opening braces
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r'((?:' # key/value pairs start; group 4
|
||||
r'{\s*' # opening braces
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r'(?:NULL|\".*?\")\s*' # option key
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r',\s*' # comma
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r'(?:NULL|\".*?\")\s*' # option value
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r'}\s*' # closing braces
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r',?\s*' # comma
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r')*)' # key/value pairs end
|
||||
r'}\s*' # closing braces
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r',?\s*' # comma
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r'(?:' # defaults start
|
||||
r'(?:NULL|\".*?\")\s*' # default value
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r',?\s*' # comma
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r')*' # defaults end
|
||||
r')?' # defs only end
|
||||
r'},') # closing braces
|
||||
# analyse option group 3
|
||||
p_info = re.compile(r'(NULL|\"(?:.|[\r\n])*?\")\s*' # description in category, info, info in category, category
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r',')
|
||||
p_info_cat = re.compile(r'(NULL|\"(?:.|[\r\n])*?\")')
|
||||
# analyse option group 4
|
||||
p_key_value = re.compile(r'{\s*' # opening braces
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r'(NULL|\".*?\")\s*' # option key; 1
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r',\s*' # comma
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r'(NULL|\".*?\")\s*' # option value; 2
|
||||
r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
|
||||
r'}')
|
||||
|
||||
p_masked = re.compile(r'([A-Z_][A-Z0-9_]+)\s*(\"(?:"\s*"|\\\s*|.)*\")')
|
||||
|
||||
p_intl = re.compile(r'(struct retro_core_option_definition \*option_defs_intl\[RETRO_LANGUAGE_LAST]) = {'
|
||||
r'((?:.|[\r\n])*?)};')
|
||||
p_set = re.compile(r'static INLINE void libretro_set_core_options\(retro_environment_t environ_cb\)'
|
||||
r'(?:.|[\r\n])*?};?\s*#ifdef __cplusplus\s*}\s*#endif')
|
||||
|
||||
p_yaml = re.compile(r'"project_id": "[0-9]+".*\s*'
|
||||
r'"api_token": "([a-zA-Z0-9]+)".*\s*'
|
||||
r'"base_path": "\./intl".*\s*'
|
||||
r'"base_url": "https://api\.crowdin\.com".*\s*'
|
||||
r'"preserve_hierarchy": true.*\s*'
|
||||
r'"files": \[\s*'
|
||||
r'\{\s*'
|
||||
r'"source": "/_us/\*\.json",.*\s*'
|
||||
r'"translation": "/_%two_letters_code%/%original_file_name%",.*\s*'
|
||||
r'"skip_untranslated_strings": true.*\s*'
|
||||
r'},\s*'
|
||||
r']')
|
|
@ -0,0 +1,620 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
"""Core options text extractor
|
||||
|
||||
The purpose of this script is to set up & provide functions for automatic generation of 'libretro_core_options_intl.h'
|
||||
from 'libretro_core_options.h' using translations from Crowdin.
|
||||
|
||||
Both v1 and v2 structs are supported. It is, however, recommended to convert v1 files to v2 using the included
|
||||
'v1_to_v2_converter.py'.
|
||||
|
||||
Usage:
|
||||
python3 path/to/core_option_translation.py "path/to/where/libretro_core_options.h & libretro_core_options_intl.h/are" "core_name"
|
||||
|
||||
This script will:
|
||||
1.) create key words for & extract the texts from libretro_core_options.h & save them into intl/_us/core_options.h
|
||||
2.) do the same for any present translations in libretro_core_options_intl.h, saving those in their respective folder
|
||||
"""
|
||||
import core_option_regex as cor
|
||||
import re
|
||||
import os
|
||||
import sys
|
||||
import json
|
||||
import urllib.request as req
|
||||
import shutil
|
||||
|
||||
# LANG_CODE_TO_R_LANG = {'_ar': 'RETRO_LANGUAGE_ARABIC',
|
||||
# '_ast': 'RETRO_LANGUAGE_ASTURIAN',
|
||||
# '_chs': 'RETRO_LANGUAGE_CHINESE_SIMPLIFIED',
|
||||
# '_cht': 'RETRO_LANGUAGE_CHINESE_TRADITIONAL',
|
||||
# '_cs': 'RETRO_LANGUAGE_CZECH',
|
||||
# '_cy': 'RETRO_LANGUAGE_WELSH',
|
||||
# '_da': 'RETRO_LANGUAGE_DANISH',
|
||||
# '_de': 'RETRO_LANGUAGE_GERMAN',
|
||||
# '_el': 'RETRO_LANGUAGE_GREEK',
|
||||
# '_eo': 'RETRO_LANGUAGE_ESPERANTO',
|
||||
# '_es': 'RETRO_LANGUAGE_SPANISH',
|
||||
# '_fa': 'RETRO_LANGUAGE_PERSIAN',
|
||||
# '_fi': 'RETRO_LANGUAGE_FINNISH',
|
||||
# '_fr': 'RETRO_LANGUAGE_FRENCH',
|
||||
# '_gl': 'RETRO_LANGUAGE_GALICIAN',
|
||||
# '_he': 'RETRO_LANGUAGE_HEBREW',
|
||||
# '_hu': 'RETRO_LANGUAGE_HUNGARIAN',
|
||||
# '_id': 'RETRO_LANGUAGE_INDONESIAN',
|
||||
# '_it': 'RETRO_LANGUAGE_ITALIAN',
|
||||
# '_ja': 'RETRO_LANGUAGE_JAPANESE',
|
||||
# '_ko': 'RETRO_LANGUAGE_KOREAN',
|
||||
# '_nl': 'RETRO_LANGUAGE_DUTCH',
|
||||
# '_oc': 'RETRO_LANGUAGE_OCCITAN',
|
||||
# '_pl': 'RETRO_LANGUAGE_POLISH',
|
||||
# '_pt_br': 'RETRO_LANGUAGE_PORTUGUESE_BRAZIL',
|
||||
# '_pt_pt': 'RETRO_LANGUAGE_PORTUGUESE_PORTUGAL',
|
||||
# '_ru': 'RETRO_LANGUAGE_RUSSIAN',
|
||||
# '_sk': 'RETRO_LANGUAGE_SLOVAK',
|
||||
# '_sv': 'RETRO_LANGUAGE_SWEDISH',
|
||||
# '_tr': 'RETRO_LANGUAGE_TURKISH',
|
||||
# '_uk': 'RETRO_LANGUAGE_UKRAINIAN',
|
||||
# '_us': 'RETRO_LANGUAGE_ENGLISH',
|
||||
# '_vn': 'RETRO_LANGUAGE_VIETNAMESE'}
|
||||
|
||||
# these are handled by RetroArch directly - no need to include them in core translations
|
||||
ON_OFFS = {'"enabled"', '"disabled"', '"true"', '"false"', '"on"', '"off"'}
|
||||
|
||||
|
||||
def remove_special_chars(text: str, char_set=0, allow_non_ascii=False) -> str:
|
||||
"""Removes special characters from a text.
|
||||
|
||||
:param text: String to be cleaned.
|
||||
:param char_set: 0 -> remove all ASCII special chars except for '_' & 'space' (default)
|
||||
1 -> remove invalid chars from file names
|
||||
:param allow_non_ascii: False -> all non-ascii characters will be removed (default)
|
||||
True -> non-ascii characters will be passed through
|
||||
:return: Clean text.
|
||||
"""
|
||||
command_chars = [chr(unicode) for unicode in tuple(range(0, 32)) + (127,)]
|
||||
special_chars = ([chr(unicode) for unicode in tuple(range(33, 48)) + tuple(range(58, 65)) + tuple(range(91, 95))
|
||||
+ (96,) + tuple(range(123, 127))],
|
||||
('\\', '/', ':', '*', '?', '"', '<', '>', '|', '#', '%',
|
||||
'&', '{', '}', '$', '!', '¸', "'", '@', '+', '='))
|
||||
res = text if allow_non_ascii \
|
||||
else text.encode('ascii', errors='ignore').decode('unicode-escape')
|
||||
|
||||
for cm in command_chars:
|
||||
res = res.replace(cm, '_')
|
||||
for sp in special_chars[char_set]:
|
||||
res = res.replace(sp, '_')
|
||||
while res.startswith('_'):
|
||||
res = res[1:]
|
||||
while res.endswith('_'):
|
||||
res = res[:-1]
|
||||
return res
|
||||
|
||||
|
||||
def clean_file_name(file_name: str) -> str:
|
||||
"""Removes characters which might make file_name inappropriate for files on some OS.
|
||||
|
||||
:param file_name: File name to be cleaned.
|
||||
:return: The clean file name.
|
||||
"""
|
||||
file_name = remove_special_chars(file_name, 1)
|
||||
file_name = re.sub(r'__+', '_', file_name.replace(' ', '_'))
|
||||
return file_name
|
||||
|
||||
|
||||
def get_struct_type_name(decl: str) -> tuple:
|
||||
""" Returns relevant parts of the struct declaration:
|
||||
type, name of the struct and the language appendix, if present.
|
||||
:param decl: The struct declaration matched by cor.p_type_name.
|
||||
:return: Tuple, e.g.: ('retro_core_option_definition', 'option_defs_us', '_us')
|
||||
"""
|
||||
struct_match = cor.p_type_name.search(decl)
|
||||
if struct_match:
|
||||
if struct_match.group(3):
|
||||
struct_type_name = struct_match.group(1, 2, 3)
|
||||
return struct_type_name
|
||||
elif struct_match.group(4):
|
||||
struct_type_name = struct_match.group(1, 2, 4)
|
||||
return struct_type_name
|
||||
else:
|
||||
struct_type_name = struct_match.group(1, 2)
|
||||
return struct_type_name
|
||||
else:
|
||||
raise ValueError(f'No or incomplete struct declaration: {decl}!\n'
|
||||
'Please make sure all structs are complete, including the type and name declaration.')
|
||||
|
||||
|
||||
def is_viable_non_dupe(text: str, comparison) -> bool:
|
||||
"""text must be longer than 2 ('""'), not 'NULL' and not in comparison.
|
||||
|
||||
:param text: String to be tested.
|
||||
:param comparison: Dictionary or set to search for text in.
|
||||
:return: bool
|
||||
"""
|
||||
return 2 < len(text) and text != 'NULL' and text not in comparison
|
||||
|
||||
|
||||
def is_viable_value(text: str) -> bool:
|
||||
"""text must be longer than 2 ('""'), not 'NULL' and text.lower() not in
|
||||
{'"enabled"', '"disabled"', '"true"', '"false"', '"on"', '"off"'}.
|
||||
|
||||
:param text: String to be tested.
|
||||
:return: bool
|
||||
"""
|
||||
return 2 < len(text) and text != 'NULL' and text.lower() not in ON_OFFS
|
||||
|
||||
|
||||
def create_non_dupe(base_name: str, opt_num: int, comparison) -> str:
|
||||
"""Makes sure base_name is not in comparison, and if it is it's renamed.
|
||||
|
||||
:param base_name: Name to check/make unique.
|
||||
:param opt_num: Number of the option base_name belongs to, used in making it unique.
|
||||
:param comparison: Dictionary or set to search for base_name in.
|
||||
:return: Unique name.
|
||||
"""
|
||||
h = base_name
|
||||
if h in comparison:
|
||||
n = 0
|
||||
h = h + '_O' + str(opt_num)
|
||||
h_end = len(h)
|
||||
while h in comparison:
|
||||
h = h[:h_end] + '_' + str(n)
|
||||
n += 1
|
||||
return h
|
||||
|
||||
|
||||
def get_texts(text: str) -> dict:
|
||||
"""Extracts the strings, which are to be translated/are the translations,
|
||||
from text and creates macro names for them.
|
||||
|
||||
:param text: The string to be parsed.
|
||||
:return: Dictionary of the form { '_<lang>': { 'macro': 'string', ... }, ... }.
|
||||
"""
|
||||
# all structs: group(0) full struct, group(1) beginning, group(2) content
|
||||
structs = cor.p_struct.finditer(text)
|
||||
hash_n_string = {}
|
||||
just_string = {}
|
||||
for struct in structs:
|
||||
struct_declaration = struct.group(1)
|
||||
struct_type_name = get_struct_type_name(struct_declaration)
|
||||
if 3 > len(struct_type_name):
|
||||
lang = '_us'
|
||||
else:
|
||||
lang = struct_type_name[2]
|
||||
if lang not in just_string:
|
||||
hash_n_string[lang] = {}
|
||||
just_string[lang] = set()
|
||||
|
||||
is_v2 = False
|
||||
pre_name = ''
|
||||
p = cor.p_info
|
||||
if 'retro_core_option_v2_definition' == struct_type_name[0]:
|
||||
is_v2 = True
|
||||
elif 'retro_core_option_v2_category' == struct_type_name[0]:
|
||||
pre_name = 'CATEGORY_'
|
||||
p = cor.p_info_cat
|
||||
|
||||
struct_content = struct.group(2)
|
||||
# 0: full option; 1: key; 2: description; 3: additional info; 4: key/value pairs
|
||||
struct_options = cor.p_option.finditer(struct_content)
|
||||
for opt, option in enumerate(struct_options):
|
||||
# group 1: key
|
||||
if option.group(1):
|
||||
opt_name = pre_name + option.group(1)
|
||||
# no special chars allowed in key
|
||||
opt_name = remove_special_chars(opt_name).upper().replace(' ', '_')
|
||||
else:
|
||||
raise ValueError(f'No option name (key) found in struct {struct_type_name[1]} option {opt}!')
|
||||
|
||||
# group 2: description0
|
||||
if option.group(2):
|
||||
desc0 = option.group(2)
|
||||
if is_viable_non_dupe(desc0, just_string[lang]):
|
||||
just_string[lang].add(desc0)
|
||||
m_h = create_non_dupe(re.sub(r'__+', '_', f'{opt_name}_LABEL'), opt, hash_n_string[lang])
|
||||
hash_n_string[lang][m_h] = desc0
|
||||
else:
|
||||
raise ValueError(f'No label found in struct {struct_type_name[1]} option {option.group(1)}!')
|
||||
|
||||
# group 3: desc1, info0, info1, category
|
||||
if option.group(3):
|
||||
infos = option.group(3)
|
||||
option_info = p.finditer(infos)
|
||||
if is_v2:
|
||||
desc1 = next(option_info).group(1)
|
||||
if is_viable_non_dupe(desc1, just_string[lang]):
|
||||
just_string[lang].add(desc1)
|
||||
m_h = create_non_dupe(re.sub(r'__+', '_', f'{opt_name}_LABEL_CAT'), opt, hash_n_string[lang])
|
||||
hash_n_string[lang][m_h] = desc1
|
||||
last = None
|
||||
m_h = None
|
||||
for j, info in enumerate(option_info):
|
||||
last = info.group(1)
|
||||
if is_viable_non_dupe(last, just_string[lang]):
|
||||
just_string[lang].add(last)
|
||||
m_h = create_non_dupe(re.sub(r'__+', '_', f'{opt_name}_INFO_{j}'), opt,
|
||||
hash_n_string[lang])
|
||||
hash_n_string[lang][m_h] = last
|
||||
if last in just_string[lang]: # category key should not be translated
|
||||
hash_n_string[lang].pop(m_h)
|
||||
just_string[lang].remove(last)
|
||||
else:
|
||||
for j, info in enumerate(option_info):
|
||||
gr1 = info.group(1)
|
||||
if is_viable_non_dupe(gr1, just_string[lang]):
|
||||
just_string[lang].add(gr1)
|
||||
m_h = create_non_dupe(re.sub(r'__+', '_', f'{opt_name}_INFO_{j}'), opt,
|
||||
hash_n_string[lang])
|
||||
hash_n_string[lang][m_h] = gr1
|
||||
else:
|
||||
raise ValueError(f'Too few arguments in struct {struct_type_name[1]} option {option.group(1)}!')
|
||||
|
||||
# group 4:
|
||||
if option.group(4):
|
||||
for j, kv_set in enumerate(cor.p_key_value.finditer(option.group(4))):
|
||||
set_key, set_value = kv_set.group(1, 2)
|
||||
if not is_viable_value(set_value):
|
||||
if not is_viable_value(set_key):
|
||||
continue
|
||||
set_value = set_key
|
||||
# re.fullmatch(r'(?:[+-][0-9]+)+', value[1:-1])
|
||||
if set_value not in just_string[lang] and not re.sub(r'[+-]', '', set_value[1:-1]).isdigit():
|
||||
clean_key = set_key[1:-1]
|
||||
clean_key = remove_special_chars(clean_key).upper().replace(' ', '_')
|
||||
m_h = create_non_dupe(re.sub(r'__+', '_', f"OPTION_VAL_{clean_key}"), opt, hash_n_string[lang])
|
||||
hash_n_string[lang][m_h] = set_value
|
||||
just_string[lang].add(set_value)
|
||||
return hash_n_string
|
||||
|
||||
|
||||
def create_msg_hash(intl_dir_path: str, core_name: str, keyword_string_dict: dict) -> dict:
|
||||
"""Creates '<core_name>.h' files in 'intl/_<lang>/' containing the macro name & string combinations.
|
||||
|
||||
:param intl_dir_path: Path to the intl directory.
|
||||
:param core_name: Name of the core, used for the files' paths.
|
||||
:param keyword_string_dict: Dictionary of the form { '_<lang>': { 'macro': 'string', ... }, ... }.
|
||||
:return: Dictionary of the form { '_<lang>': 'path/to/file (./intl/_<lang>/<core_name>.h)', ... }.
|
||||
"""
|
||||
files = {}
|
||||
for localisation in keyword_string_dict:
|
||||
path = os.path.join(intl_dir_path, core_name) # intl/<core_name>/
|
||||
files[localisation] = os.path.join(path, localisation + '.h') # intl/<core_name>/_<lang>.h
|
||||
if not os.path.exists(path):
|
||||
os.makedirs(path)
|
||||
with open(files[localisation], 'w', encoding='utf-8') as crowdin_file:
|
||||
out_text = ''
|
||||
for keyword in keyword_string_dict[localisation]:
|
||||
out_text = f'{out_text}{keyword} {keyword_string_dict[localisation][keyword]}\n'
|
||||
crowdin_file.write(out_text)
|
||||
return files
|
||||
|
||||
|
||||
def h2json(file_paths: dict) -> dict:
|
||||
"""Converts .h files pointed to by file_paths into .jsons.
|
||||
|
||||
:param file_paths: Dictionary of the form { '_<lang>': 'path/to/file (./intl/_<lang>/<core_name>.h)', ... }.
|
||||
:return: Dictionary of the form { '_<lang>': 'path/to/file (./intl/_<lang>/<core_name>.json)', ... }.
|
||||
"""
|
||||
jsons = {}
|
||||
for file_lang in file_paths:
|
||||
if not os.path.isfile(file_paths[file_lang]):
|
||||
continue
|
||||
|
||||
jsons[file_lang] = file_paths[file_lang][:-2] + '.json'
|
||||
|
||||
p = cor.p_masked
|
||||
|
||||
with open(file_paths[file_lang], 'r+', encoding='utf-8') as h_file:
|
||||
text = h_file.read()
|
||||
result = p.finditer(text)
|
||||
messages = {}
|
||||
for msg in result:
|
||||
key, val = msg.group(1, 2)
|
||||
if key not in messages:
|
||||
if key and val:
|
||||
# unescape & remove "\n"
|
||||
messages[key] = re.sub(r'"\s*(?:(?:/\*(?:.|[\r\n])*?\*/|//.*[\r\n]+)\s*)*"',
|
||||
'\\\n', val[1:-1].replace('\\\"', '"'))
|
||||
else:
|
||||
print(f"DUPLICATE KEY in {file_paths[file_lang]}: {key}")
|
||||
with open(jsons[file_lang], 'w', encoding='utf-8') as json_file:
|
||||
json.dump(messages, json_file, indent=2)
|
||||
|
||||
return jsons
|
||||
|
||||
|
||||
def json2h(intl_dir_path: str, file_list) -> None:
|
||||
"""Converts .json file in json_file_path into an .h ready to be included in C code.
|
||||
|
||||
:param intl_dir_path: Path to the intl/<core_name> directory.
|
||||
:param file_list: Iterator of os.DirEntry objects. Contains localisation files to convert.
|
||||
:return: None
|
||||
"""
|
||||
|
||||
p = cor.p_masked
|
||||
|
||||
def update(s_messages, s_template, s_source_messages, file_name):
|
||||
translation = ''
|
||||
template_messages = p.finditer(s_template)
|
||||
for tp_msg in template_messages:
|
||||
old_key = tp_msg.group(1)
|
||||
if old_key in s_messages and s_messages[old_key] != s_source_messages[old_key]:
|
||||
tl_msg_val = s_messages[old_key]
|
||||
tl_msg_val = tl_msg_val.replace('"', '\\\"').replace('\n', '') # escape
|
||||
translation = ''.join((translation, '#define ', old_key, file_name.upper(), f' "{tl_msg_val}"\n'))
|
||||
|
||||
else: # Remove English duplicates and non-translatable strings
|
||||
translation = ''.join((translation, '#define ', old_key, file_name.upper(), ' NULL\n'))
|
||||
return translation
|
||||
|
||||
us_h = os.path.join(intl_dir_path, '_us.h')
|
||||
us_json = os.path.join(intl_dir_path, '_us.json')
|
||||
|
||||
with open(us_h, 'r', encoding='utf-8') as template_file:
|
||||
template = template_file.read()
|
||||
with open(us_json, 'r+', encoding='utf-8') as source_json_file:
|
||||
source_messages = json.load(source_json_file)
|
||||
|
||||
for file in file_list:
|
||||
if file.name.lower().startswith('_us') \
|
||||
or file.name.lower().endswith('.h') \
|
||||
or file.is_dir():
|
||||
continue
|
||||
|
||||
with open(file.path, 'r+', encoding='utf-8') as json_file:
|
||||
messages = json.load(json_file)
|
||||
new_translation = update(messages, template, source_messages, os.path.splitext(file.name)[0])
|
||||
with open(os.path.splitext(file.path)[0] + '.h', 'w', encoding='utf-8') as h_file:
|
||||
h_file.seek(0)
|
||||
h_file.write(new_translation)
|
||||
h_file.truncate()
|
||||
return
|
||||
|
||||
|
||||
def get_crowdin_client(dir_path: str) -> str:
|
||||
"""Makes sure the Crowdin CLI client is present. If it isn't, it is fetched & extracted.
|
||||
|
||||
:return: The path to 'crowdin-cli.jar'.
|
||||
"""
|
||||
jar_name = 'crowdin-cli.jar'
|
||||
jar_path = os.path.join(dir_path, jar_name)
|
||||
|
||||
if not os.path.isfile(jar_path):
|
||||
print('Downloading crowdin-cli.jar')
|
||||
crowdin_cli_file = os.path.join(dir_path, 'crowdin-cli.zip')
|
||||
crowdin_cli_url = 'https://downloads.crowdin.com/cli/v3/crowdin-cli.zip'
|
||||
req.urlretrieve(crowdin_cli_url, crowdin_cli_file)
|
||||
import zipfile
|
||||
with zipfile.ZipFile(crowdin_cli_file, 'r') as zip_ref:
|
||||
jar_dir = zip_ref.namelist()[0]
|
||||
for file in zip_ref.namelist():
|
||||
if file.endswith(jar_name):
|
||||
jar_file = file
|
||||
break
|
||||
zip_ref.extract(jar_file)
|
||||
os.rename(jar_file, jar_path)
|
||||
os.remove(crowdin_cli_file)
|
||||
shutil.rmtree(jar_dir)
|
||||
return jar_path
|
||||
|
||||
|
||||
def create_intl_file(localisation_file_path: str, intl_dir_path: str, text: str, file_path: str) -> None:
|
||||
"""Creates 'libretro_core_options_intl.h' from Crowdin translations.
|
||||
|
||||
:param localisation_file_path: Path to 'libretro_core_options_intl.h'
|
||||
:param intl_dir_path: Path to the intl/<core_name> directory.
|
||||
:param text: Content of the 'libretro_core_options.h' being translated.
|
||||
:param file_path: Path to the '_us.h' file, containing the original English texts.
|
||||
:return: None
|
||||
"""
|
||||
msg_dict = {}
|
||||
lang_up = ''
|
||||
|
||||
def replace_pair(pair_match):
|
||||
"""Replaces a key-value-pair of an option with the macros corresponding to the language.
|
||||
|
||||
:param pair_match: The re match object representing the key-value-pair block.
|
||||
:return: Replacement string.
|
||||
"""
|
||||
offset = pair_match.start(0)
|
||||
if pair_match.group(1): # key
|
||||
if pair_match.group(2) in msg_dict: # value
|
||||
val = msg_dict[pair_match.group(2)] + lang_up
|
||||
elif pair_match.group(1) in msg_dict: # use key if value not viable (e.g. NULL)
|
||||
val = msg_dict[pair_match.group(1)] + lang_up
|
||||
else:
|
||||
return pair_match.group(0)
|
||||
else:
|
||||
return pair_match.group(0)
|
||||
res = pair_match.group(0)[:pair_match.start(2) - offset] + val \
|
||||
+ pair_match.group(0)[pair_match.end(2) - offset:]
|
||||
return res
|
||||
|
||||
def replace_info(info_match):
|
||||
"""Replaces the 'additional strings' of an option with the macros corresponding to the language.
|
||||
|
||||
:param info_match: The re match object representing the 'additional strings' block.
|
||||
:return: Replacement string.
|
||||
"""
|
||||
offset = info_match.start(0)
|
||||
if info_match.group(1) in msg_dict:
|
||||
res = info_match.group(0)[:info_match.start(1) - offset] + \
|
||||
msg_dict[info_match.group(1)] + lang_up + \
|
||||
info_match.group(0)[info_match.end(1) - offset:]
|
||||
return res
|
||||
else:
|
||||
return info_match.group(0)
|
||||
|
||||
def replace_option(option_match):
|
||||
"""Replaces strings within an option
|
||||
'{ "opt_key", "label", "additional strings", ..., { {"key", "value"}, ... }, ... }'
|
||||
within a struct with the macros corresponding to the language:
|
||||
'{ "opt_key", MACRO_LABEL, MACRO_STRINGS, ..., { {"key", MACRO_VALUE}, ... }, ... }'
|
||||
|
||||
:param option_match: The re match object representing the option.
|
||||
:return: Replacement string.
|
||||
"""
|
||||
# label
|
||||
offset = option_match.start(0)
|
||||
if option_match.group(2):
|
||||
res = option_match.group(0)[:option_match.start(2) - offset] + msg_dict[option_match.group(2)] + lang_up
|
||||
else:
|
||||
return option_match.group(0)
|
||||
# additional block
|
||||
if option_match.group(3):
|
||||
res = res + option_match.group(0)[option_match.end(2) - offset:option_match.start(3) - offset]
|
||||
new_info = p.sub(replace_info, option_match.group(3))
|
||||
res = res + new_info
|
||||
else:
|
||||
return res + option_match.group(0)[option_match.end(2) - offset:]
|
||||
# key-value-pairs
|
||||
if option_match.group(4):
|
||||
res = res + option_match.group(0)[option_match.end(3) - offset:option_match.start(4) - offset]
|
||||
new_pairs = cor.p_key_value.sub(replace_pair, option_match.group(4))
|
||||
res = res + new_pairs + option_match.group(0)[option_match.end(4) - offset:]
|
||||
else:
|
||||
res = res + option_match.group(0)[option_match.end(3) - offset:]
|
||||
|
||||
return res
|
||||
|
||||
# ------------------------------------------------------------------------------------
|
||||
|
||||
with open(file_path, 'r+', encoding='utf-8') as template: # intl/<core_name>/_us.h
|
||||
masked_msgs = cor.p_masked.finditer(template.read())
|
||||
|
||||
for msg in masked_msgs:
|
||||
msg_dict[msg.group(2)] = msg.group(1)
|
||||
|
||||
# top of the file - in case there is no file to copy it from
|
||||
out_txt = "#ifndef LIBRETRO_CORE_OPTIONS_INTL_H__\n" \
|
||||
"#define LIBRETRO_CORE_OPTIONS_INTL_H__\n\n" \
|
||||
"#if defined(_MSC_VER) && (_MSC_VER >= 1500 && _MSC_VER < 1900)\n" \
|
||||
"/* https://support.microsoft.com/en-us/kb/980263 */\n" \
|
||||
'#pragma execution_character_set("utf-8")\n' \
|
||||
"#pragma warning(disable:4566)\n" \
|
||||
"#endif\n\n" \
|
||||
"#include <libretro.h>\n\n" \
|
||||
'#ifdef __cplusplus\n' \
|
||||
'extern "C" {\n' \
|
||||
'#endif\n'
|
||||
|
||||
if os.path.isfile(localisation_file_path):
|
||||
# copy top of the file for re-use
|
||||
with open(localisation_file_path, 'r', encoding='utf-8') as intl: # libretro_core_options_intl.h
|
||||
in_text = intl.read()
|
||||
intl_start = re.search(re.escape('/*\n'
|
||||
' ********************************\n'
|
||||
' * Core Option Definitions\n'
|
||||
' ********************************\n'
|
||||
'*/\n'), in_text)
|
||||
if intl_start:
|
||||
out_txt = in_text[:intl_start.end(0)]
|
||||
else:
|
||||
intl_start = re.search(re.escape('#ifdef __cplusplus\n'
|
||||
'extern "C" {\n'
|
||||
'#endif\n'), in_text)
|
||||
if intl_start:
|
||||
out_txt = in_text[:intl_start.end(0)]
|
||||
|
||||
# only write to file, if there is anything worthwhile to write!
|
||||
overwrite = False
|
||||
|
||||
# iterate through localisation files
|
||||
files = {}
|
||||
for file in os.scandir(intl_dir_path):
|
||||
files[file.name] = {'is_file': file.is_file(), 'path': file.path}
|
||||
for file in sorted(files): # intl/<core_name>/_*
|
||||
if files[file]['is_file'] \
|
||||
and file.startswith('_') \
|
||||
and file.endswith('.h') \
|
||||
and not file.startswith('_us'):
|
||||
translation_path = files[file]['path'] # <core_name>_<lang>.h
|
||||
# all structs: group(0) full struct, group(1) beginning, group(2) content
|
||||
struct_groups = cor.p_struct.finditer(text)
|
||||
lang_low = os.path.splitext(file)[0].lower()
|
||||
lang_up = lang_low.upper()
|
||||
out_txt = out_txt + f'/* RETRO_LANGUAGE{lang_up} */\n\n' # /* RETRO_LANGUAGE_NM */
|
||||
|
||||
# copy adjusted translations (makros)
|
||||
with open(translation_path, 'r+', encoding='utf-8') as f_in: # <core name>.h
|
||||
out_txt = out_txt + f_in.read() + '\n'
|
||||
# replace English texts with makros
|
||||
for construct in struct_groups:
|
||||
declaration = construct.group(1)
|
||||
struct_type_name = get_struct_type_name(declaration)
|
||||
if 3 > len(struct_type_name): # no language specifier
|
||||
new_decl = re.sub(re.escape(struct_type_name[1]), struct_type_name[1] + lang_low, declaration)
|
||||
else:
|
||||
new_decl = re.sub(re.escape(struct_type_name[2]), lang_low, declaration)
|
||||
if '_us' != struct_type_name[2]:
|
||||
continue
|
||||
|
||||
p = cor.p_info
|
||||
if 'retro_core_option_v2_category' == struct_type_name[0]:
|
||||
p = cor.p_info_cat
|
||||
offset_construct = construct.start(0)
|
||||
start = construct.end(1) - offset_construct
|
||||
end = construct.start(2) - offset_construct
|
||||
out_txt = out_txt + new_decl + construct.group(0)[start:end]
|
||||
|
||||
content = construct.group(2)
|
||||
new_content = cor.p_option.sub(replace_option, content)
|
||||
|
||||
start = construct.end(2) - offset_construct
|
||||
out_txt = out_txt + new_content + construct.group(0)[start:] + '\n'
|
||||
|
||||
# for v2
|
||||
if 'retro_core_option_v2_definition' == struct_type_name[0]:
|
||||
out_txt = out_txt + f'struct retro_core_options_v2 options{lang_low}' \
|
||||
' = {\n' \
|
||||
f' option_cats{lang_low},\n' \
|
||||
f' option_defs{lang_low}\n' \
|
||||
'};\n\n'
|
||||
# if it got this far, we've got something to write
|
||||
overwrite = True
|
||||
|
||||
# only write to file, if there is anything worthwhile to write!
|
||||
if overwrite:
|
||||
with open(localisation_file_path, 'w', encoding='utf-8') as intl:
|
||||
intl.write(out_txt + '\n#ifdef __cplusplus\n'
|
||||
'}\n#endif\n'
|
||||
'\n#endif')
|
||||
return
|
||||
|
||||
|
||||
# -------------------- MAIN -------------------- #
|
||||
|
||||
if __name__ == '__main__':
|
||||
try:
|
||||
if os.path.isfile(sys.argv[1]):
|
||||
_temp = os.path.dirname(sys.argv[1])
|
||||
else:
|
||||
_temp = sys.argv[1]
|
||||
while _temp.endswith('/') or _temp.endswith('\\'):
|
||||
_temp = _temp[:-1]
|
||||
TARGET_DIR_PATH = _temp
|
||||
except IndexError:
|
||||
TARGET_DIR_PATH = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
|
||||
print("No path provided, assuming parent directory:\n" + TARGET_DIR_PATH)
|
||||
|
||||
CORE_NAME = clean_file_name(sys.argv[2])
|
||||
|
||||
DIR_PATH = os.path.dirname(os.path.realpath(__file__))
|
||||
H_FILE_PATH = os.path.join(TARGET_DIR_PATH, 'libretro_core_options.h')
|
||||
INTL_FILE_PATH = os.path.join(TARGET_DIR_PATH, 'libretro_core_options_intl.h')
|
||||
|
||||
print('Getting texts from libretro_core_options.h')
|
||||
with open(H_FILE_PATH, 'r+', encoding='utf-8') as _h_file:
|
||||
_main_text = _h_file.read()
|
||||
_hash_n_str = get_texts(_main_text)
|
||||
_files = create_msg_hash(DIR_PATH, CORE_NAME, _hash_n_str)
|
||||
_source_jsons = h2json(_files)
|
||||
|
||||
print('Getting texts from libretro_core_options_intl.h')
|
||||
if os.path.isfile(INTL_FILE_PATH):
|
||||
with open(INTL_FILE_PATH, 'r+', encoding='utf-8') as _intl_file:
|
||||
_intl_text = _intl_file.read()
|
||||
_hash_n_str_intl = get_texts(_intl_text)
|
||||
_intl_files = create_msg_hash(DIR_PATH, CORE_NAME, _hash_n_str_intl)
|
||||
_intl_jsons = h2json(_intl_files)
|
||||
|
||||
print('\nAll done!')
|
|
@ -0,0 +1,13 @@
|
|||
"project_id": "380544"
|
||||
"api_token": "_secret_"
|
||||
"base_url": "https://api.crowdin.com"
|
||||
"preserve_hierarchy": true
|
||||
|
||||
"files":
|
||||
[
|
||||
{
|
||||
"source": "/intl/_core_name_/_us.json",
|
||||
"dest": "/_core_name_/_core_name_.json",
|
||||
"translation": "/intl/_core_name_/_%two_letters_code%.json",
|
||||
},
|
||||
]
|
|
@ -0,0 +1,30 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
import core_option_translation as t
|
||||
|
||||
if __name__ == '__main__':
|
||||
try:
|
||||
if t.os.path.isfile(t.sys.argv[1]):
|
||||
_temp = t.os.path.dirname(t.sys.argv[1])
|
||||
else:
|
||||
_temp = t.sys.argv[1]
|
||||
while _temp.endswith('/') or _temp.endswith('\\'):
|
||||
_temp = _temp[:-1]
|
||||
TARGET_DIR_PATH = _temp
|
||||
except IndexError:
|
||||
TARGET_DIR_PATH = t.os.path.dirname(t.os.path.dirname(t.os.path.realpath(__file__)))
|
||||
print("No path provided, assuming parent directory:\n" + TARGET_DIR_PATH)
|
||||
|
||||
CORE_NAME = t.clean_file_name(t.sys.argv[2])
|
||||
DIR_PATH = t.os.path.dirname(t.os.path.realpath(__file__))
|
||||
H_FILE_PATH = t.os.path.join(TARGET_DIR_PATH, 'libretro_core_options.h')
|
||||
|
||||
print('Getting texts from libretro_core_options.h')
|
||||
with open(H_FILE_PATH, 'r+', encoding='utf-8') as _h_file:
|
||||
_main_text = _h_file.read()
|
||||
_hash_n_str = t.get_texts(_main_text)
|
||||
_files = t.create_msg_hash(DIR_PATH, CORE_NAME, _hash_n_str)
|
||||
|
||||
_source_jsons = t.h2json(_files)
|
||||
|
||||
print('\nAll done!')
|
|
@ -0,0 +1,93 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
import re
|
||||
import os
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import urllib.request
|
||||
import zipfile
|
||||
import core_option_translation as t
|
||||
|
||||
# -------------------- MAIN -------------------- #
|
||||
|
||||
if __name__ == '__main__':
|
||||
# Check Crowdin API Token and core name
|
||||
try:
|
||||
API_KEY = sys.argv[1]
|
||||
CORE_NAME = t.clean_file_name(sys.argv[2])
|
||||
except IndexError as e:
|
||||
print('Please provide Crowdin API Token and core name!')
|
||||
raise e
|
||||
|
||||
DIR_PATH = t.os.path.dirname(t.os.path.realpath(__file__))
|
||||
YAML_PATH = t.os.path.join(DIR_PATH, 'crowdin.yaml')
|
||||
|
||||
# Apply Crowdin API Key
|
||||
with open(YAML_PATH, 'r') as crowdin_config_file:
|
||||
crowdin_config = crowdin_config_file.read()
|
||||
crowdin_config = re.sub(r'"api_token": "_secret_"',
|
||||
f'"api_token": "{API_KEY}"',
|
||||
crowdin_config, 1)
|
||||
crowdin_config = re.sub(r'/_core_name_',
|
||||
f'/{CORE_NAME}'
|
||||
, crowdin_config)
|
||||
with open(YAML_PATH, 'w') as crowdin_config_file:
|
||||
crowdin_config_file.write(crowdin_config)
|
||||
|
||||
try:
|
||||
# Download Crowdin CLI
|
||||
jar_name = 'crowdin-cli.jar'
|
||||
jar_path = t.os.path.join(DIR_PATH, jar_name)
|
||||
crowdin_cli_file = 'crowdin-cli.zip'
|
||||
crowdin_cli_url = 'https://downloads.crowdin.com/cli/v3/' + crowdin_cli_file
|
||||
crowdin_cli_path = t.os.path.join(DIR_PATH, crowdin_cli_file)
|
||||
|
||||
if not os.path.isfile(t.os.path.join(DIR_PATH, jar_name)):
|
||||
print('download crowdin-cli.jar')
|
||||
urllib.request.urlretrieve(crowdin_cli_url, crowdin_cli_path)
|
||||
with zipfile.ZipFile(crowdin_cli_path, 'r') as zip_ref:
|
||||
jar_dir = t.os.path.join(DIR_PATH, zip_ref.namelist()[0])
|
||||
for file in zip_ref.namelist():
|
||||
if file.endswith(jar_name):
|
||||
jar_file = file
|
||||
break
|
||||
zip_ref.extract(jar_file, path=DIR_PATH)
|
||||
os.rename(t.os.path.join(DIR_PATH, jar_file), jar_path)
|
||||
os.remove(crowdin_cli_path)
|
||||
shutil.rmtree(jar_dir)
|
||||
|
||||
print('upload source *.json')
|
||||
subprocess.run(['java', '-jar', jar_path, 'upload', 'sources', '--config', YAML_PATH])
|
||||
|
||||
# Reset Crowdin API Key
|
||||
with open(YAML_PATH, 'r') as crowdin_config_file:
|
||||
crowdin_config = crowdin_config_file.read()
|
||||
crowdin_config = re.sub(r'"api_token": ".*?"',
|
||||
'"api_token": "_secret_"',
|
||||
crowdin_config, 1)
|
||||
|
||||
# TODO this is NOT safe!
|
||||
crowdin_config = re.sub(re.escape(f'/{CORE_NAME}'),
|
||||
'/_core_name_',
|
||||
crowdin_config)
|
||||
|
||||
with open(YAML_PATH, 'w') as crowdin_config_file:
|
||||
crowdin_config_file.write(crowdin_config)
|
||||
|
||||
except Exception as e:
|
||||
# Try really hard to reset Crowdin API Key
|
||||
with open(YAML_PATH, 'r') as crowdin_config_file:
|
||||
crowdin_config = crowdin_config_file.read()
|
||||
crowdin_config = re.sub(r'"api_token": ".*?"',
|
||||
'"api_token": "_secret_"',
|
||||
crowdin_config, 1)
|
||||
|
||||
# TODO this is NOT safe!
|
||||
crowdin_config = re.sub(re.escape(f'/{CORE_NAME}'),
|
||||
'/_core_name_',
|
||||
crowdin_config)
|
||||
|
||||
with open(YAML_PATH, 'w') as crowdin_config_file:
|
||||
crowdin_config_file.write(crowdin_config)
|
||||
raise e
|
|
@ -0,0 +1,39 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
import core_option_translation as t
|
||||
|
||||
if __name__ == '__main__':
|
||||
try:
|
||||
if t.os.path.isfile(t.sys.argv[1]):
|
||||
_temp = t.os.path.dirname(t.sys.argv[1])
|
||||
else:
|
||||
_temp = t.sys.argv[1]
|
||||
while _temp.endswith('/') or _temp.endswith('\\'):
|
||||
_temp = _temp[:-1]
|
||||
TARGET_DIR_PATH = _temp
|
||||
except IndexError:
|
||||
TARGET_DIR_PATH = t.os.path.dirname(t.os.path.dirname(t.os.path.realpath(__file__)))
|
||||
print("No path provided, assuming parent directory:\n" + TARGET_DIR_PATH)
|
||||
|
||||
CORE_NAME = t.clean_file_name(t.sys.argv[2])
|
||||
DIR_PATH = t.os.path.dirname(t.os.path.realpath(__file__))
|
||||
LOCALISATIONS_PATH = t.os.path.join(DIR_PATH, CORE_NAME)
|
||||
US_FILE_PATH = t.os.path.join(LOCALISATIONS_PATH, '_us.h')
|
||||
H_FILE_PATH = t.os.path.join(TARGET_DIR_PATH, 'libretro_core_options.h')
|
||||
INTL_FILE_PATH = t.os.path.join(TARGET_DIR_PATH, 'libretro_core_options_intl.h')
|
||||
|
||||
print('Getting texts from libretro_core_options.h')
|
||||
with open(H_FILE_PATH, 'r+', encoding='utf-8') as _h_file:
|
||||
_main_text = _h_file.read()
|
||||
_hash_n_str = t.get_texts(_main_text)
|
||||
_files = t.create_msg_hash(DIR_PATH, CORE_NAME, _hash_n_str)
|
||||
_source_jsons = t.h2json(_files)
|
||||
|
||||
print('Converting translations *.json to *.h:')
|
||||
localisation_files = t.os.scandir(LOCALISATIONS_PATH)
|
||||
t.json2h(LOCALISATIONS_PATH, localisation_files)
|
||||
|
||||
print('Constructing libretro_core_options_intl.h')
|
||||
t.create_intl_file(INTL_FILE_PATH, LOCALISATIONS_PATH, _main_text, _files["_us"])
|
||||
|
||||
print('\nAll done!')
|
|
@ -0,0 +1,93 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
import re
|
||||
import os
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import urllib.request
|
||||
import zipfile
|
||||
import core_option_translation as t
|
||||
|
||||
# -------------------- MAIN -------------------- #
|
||||
|
||||
if __name__ == '__main__':
|
||||
# Check Crowdin API Token and core name
|
||||
try:
|
||||
API_KEY = sys.argv[1]
|
||||
CORE_NAME = t.clean_file_name(sys.argv[2])
|
||||
except IndexError as e:
|
||||
print('Please provide Crowdin API Token and core name!')
|
||||
raise e
|
||||
|
||||
DIR_PATH = t.os.path.dirname(t.os.path.realpath(__file__))
|
||||
YAML_PATH = t.os.path.join(DIR_PATH, 'crowdin.yaml')
|
||||
|
||||
# Apply Crowdin API Key
|
||||
with open(YAML_PATH, 'r') as crowdin_config_file:
|
||||
crowdin_config = crowdin_config_file.read()
|
||||
crowdin_config = re.sub(r'"api_token": "_secret_"',
|
||||
f'"api_token": "{API_KEY}"',
|
||||
crowdin_config, 1)
|
||||
crowdin_config = re.sub(r'/_core_name_',
|
||||
f'/{CORE_NAME}'
|
||||
, crowdin_config)
|
||||
with open(YAML_PATH, 'w') as crowdin_config_file:
|
||||
crowdin_config_file.write(crowdin_config)
|
||||
|
||||
try:
|
||||
# Download Crowdin CLI
|
||||
jar_name = 'crowdin-cli.jar'
|
||||
jar_path = t.os.path.join(DIR_PATH, jar_name)
|
||||
crowdin_cli_file = 'crowdin-cli.zip'
|
||||
crowdin_cli_url = 'https://downloads.crowdin.com/cli/v3/' + crowdin_cli_file
|
||||
crowdin_cli_path = t.os.path.join(DIR_PATH, crowdin_cli_file)
|
||||
|
||||
if not os.path.isfile(t.os.path.join(DIR_PATH, jar_name)):
|
||||
print('download crowdin-cli.jar')
|
||||
urllib.request.urlretrieve(crowdin_cli_url, crowdin_cli_path)
|
||||
with zipfile.ZipFile(crowdin_cli_path, 'r') as zip_ref:
|
||||
jar_dir = t.os.path.join(DIR_PATH, zip_ref.namelist()[0])
|
||||
for file in zip_ref.namelist():
|
||||
if file.endswith(jar_name):
|
||||
jar_file = file
|
||||
break
|
||||
zip_ref.extract(jar_file, path=DIR_PATH)
|
||||
os.rename(t.os.path.join(DIR_PATH, jar_file), jar_path)
|
||||
os.remove(crowdin_cli_path)
|
||||
shutil.rmtree(jar_dir)
|
||||
|
||||
print('download translation *.json')
|
||||
subprocess.run(['java', '-jar', jar_path, 'download', '--config', YAML_PATH])
|
||||
|
||||
# Reset Crowdin API Key
|
||||
with open(YAML_PATH, 'r') as crowdin_config_file:
|
||||
crowdin_config = crowdin_config_file.read()
|
||||
crowdin_config = re.sub(r'"api_token": ".*?"',
|
||||
'"api_token": "_secret_"',
|
||||
crowdin_config, 1)
|
||||
|
||||
# TODO this is NOT safe!
|
||||
crowdin_config = re.sub(re.escape(f'/{CORE_NAME}'),
|
||||
'/_core_name_',
|
||||
crowdin_config)
|
||||
|
||||
with open(YAML_PATH, 'w') as crowdin_config_file:
|
||||
crowdin_config_file.write(crowdin_config)
|
||||
|
||||
except Exception as e:
|
||||
# Try really hard to reset Crowdin API Key
|
||||
with open(YAML_PATH, 'r') as crowdin_config_file:
|
||||
crowdin_config = crowdin_config_file.read()
|
||||
crowdin_config = re.sub(r'"api_token": ".*?"',
|
||||
'"api_token": "_secret_"',
|
||||
crowdin_config, 1)
|
||||
|
||||
# TODO this is NOT safe!
|
||||
crowdin_config = re.sub(re.escape(f'/{CORE_NAME}'),
|
||||
'/_core_name_',
|
||||
crowdin_config)
|
||||
|
||||
with open(YAML_PATH, 'w') as crowdin_config_file:
|
||||
crowdin_config_file.write(crowdin_config)
|
||||
raise e
|
|
@ -0,0 +1,16 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
import sys
|
||||
import subprocess
|
||||
|
||||
try:
|
||||
api_key = sys.argv[1]
|
||||
core_name = sys.argv[2]
|
||||
dir_path = sys.argv[3]
|
||||
except IndexError as e:
|
||||
print('Please provide path to libretro_core_options.h, Crowdin API Token and core name!')
|
||||
raise e
|
||||
|
||||
subprocess.run(['python3', 'intl/crowdin_prep.py', dir_path, core_name])
|
||||
subprocess.run(['python3', 'intl/crowdin_translation_download.py', api_key, core_name])
|
||||
subprocess.run(['python3', 'intl/crowdin_translate.py', dir_path, core_name])
|
|
@ -0,0 +1,125 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
import re
|
||||
import os
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import urllib.request
|
||||
import zipfile
|
||||
import core_option_translation as t
|
||||
|
||||
# -------------------- MAIN -------------------- #
|
||||
|
||||
if __name__ == '__main__':
|
||||
# Check Crowdin API Token and core name
|
||||
try:
|
||||
API_KEY = sys.argv[1]
|
||||
CORE_NAME = t.clean_file_name(sys.argv[2])
|
||||
except IndexError as e:
|
||||
print('Please provide Crowdin API Token and core name!')
|
||||
raise e
|
||||
|
||||
DIR_PATH = os.path.dirname(os.path.realpath(__file__))
|
||||
YAML_PATH = os.path.join(DIR_PATH, 'crowdin.yaml')
|
||||
|
||||
# Apply Crowdin API Key
|
||||
with open(YAML_PATH, 'r') as crowdin_config_file:
|
||||
crowdin_config = crowdin_config_file.read()
|
||||
crowdin_config = re.sub(r'"api_token": "_secret_"',
|
||||
f'"api_token": "{API_KEY}"',
|
||||
crowdin_config, 1)
|
||||
crowdin_config = re.sub(r'/_core_name_',
|
||||
f'/{CORE_NAME}'
|
||||
, crowdin_config)
|
||||
with open(YAML_PATH, 'w') as crowdin_config_file:
|
||||
crowdin_config_file.write(crowdin_config)
|
||||
|
||||
try:
|
||||
# Download Crowdin CLI
|
||||
jar_name = 'crowdin-cli.jar'
|
||||
jar_path = os.path.join(DIR_PATH, jar_name)
|
||||
crowdin_cli_file = 'crowdin-cli.zip'
|
||||
crowdin_cli_url = 'https://downloads.crowdin.com/cli/v3/' + crowdin_cli_file
|
||||
crowdin_cli_path = os.path.join(DIR_PATH, crowdin_cli_file)
|
||||
|
||||
if not os.path.isfile(os.path.join(DIR_PATH, jar_name)):
|
||||
print('download crowdin-cli.jar')
|
||||
urllib.request.urlretrieve(crowdin_cli_url, crowdin_cli_path)
|
||||
with zipfile.ZipFile(crowdin_cli_path, 'r') as zip_ref:
|
||||
jar_dir = os.path.join(DIR_PATH, zip_ref.namelist()[0])
|
||||
for file in zip_ref.namelist():
|
||||
if file.endswith(jar_name):
|
||||
jar_file = file
|
||||
break
|
||||
zip_ref.extract(jar_file, path=DIR_PATH)
|
||||
os.rename(os.path.join(DIR_PATH, jar_file), jar_path)
|
||||
os.remove(crowdin_cli_path)
|
||||
shutil.rmtree(jar_dir)
|
||||
|
||||
print('upload source & translations *.json')
|
||||
subprocess.run(['java', '-jar', jar_path, 'upload', 'sources', '--config', YAML_PATH])
|
||||
subprocess.run(['java', '-jar', jar_path, 'upload', 'translations', '--config', YAML_PATH])
|
||||
|
||||
print('wait for crowdin server to process data')
|
||||
time.sleep(10)
|
||||
|
||||
print('download translation *.json')
|
||||
subprocess.run(['java', '-jar', jar_path, 'download', '--config', YAML_PATH])
|
||||
|
||||
# Reset Crowdin API Key
|
||||
with open(YAML_PATH, 'r') as crowdin_config_file:
|
||||
crowdin_config = crowdin_config_file.read()
|
||||
crowdin_config = re.sub(r'"api_token": ".*?"', '"api_token": "_secret_"', crowdin_config, 1)
|
||||
|
||||
# TODO this is NOT safe!
|
||||
crowdin_config = re.sub(re.escape(f'/{CORE_NAME}'),
|
||||
'/_core_name_',
|
||||
crowdin_config)
|
||||
|
||||
with open(YAML_PATH, 'w') as crowdin_config_file:
|
||||
crowdin_config_file.write(crowdin_config)
|
||||
|
||||
with open('intl/upload_workflow.py', 'r') as workflow:
|
||||
workflow_config = workflow.read()
|
||||
workflow_config = workflow_config.replace(
|
||||
"subprocess.run(['python3', 'intl/core_option_translation.py', dir_path, core_name])",
|
||||
"subprocess.run(['python3', 'intl/crowdin_prep.py', dir_path, core_name])"
|
||||
)
|
||||
workflow_config = workflow_config.replace(
|
||||
"subprocess.run(['python3', 'intl/initial_sync.py', api_key, core_name])",
|
||||
"subprocess.run(['python3', 'intl/crowdin_source_upload.py', api_key, core_name])"
|
||||
)
|
||||
with open('intl/upload_workflow.py', 'w') as workflow:
|
||||
workflow.write(workflow_config)
|
||||
|
||||
with open('intl/download_workflow.py', 'r') as workflow:
|
||||
workflow_config = workflow.read()
|
||||
workflow_config = workflow_config.replace(
|
||||
"subprocess.run(['python3', 'intl/core_option_translation.py', dir_path, core_name])",
|
||||
"subprocess.run(['python3', 'intl/crowdin_prep.py', dir_path, core_name])"
|
||||
)
|
||||
workflow_config = workflow_config.replace(
|
||||
"subprocess.run(['python3', 'intl/initial_sync.py', api_key, core_name])",
|
||||
"subprocess.run(['python3', 'intl/crowdin_translation_download.py', api_key, core_name])"
|
||||
)
|
||||
with open('intl/download_workflow.py', 'w') as workflow:
|
||||
workflow.write(workflow_config)
|
||||
|
||||
except Exception as e:
|
||||
# Try really hard to reset Crowdin API Key
|
||||
with open(YAML_PATH, 'r') as crowdin_config_file:
|
||||
crowdin_config = crowdin_config_file.read()
|
||||
crowdin_config = re.sub(r'"api_token": ".*?"',
|
||||
'"api_token": "_secret_"',
|
||||
crowdin_config, 1)
|
||||
|
||||
# TODO this is NOT safe!
|
||||
crowdin_config = re.sub(re.escape(f'/{CORE_NAME}'),
|
||||
'/_core_name_',
|
||||
crowdin_config)
|
||||
|
||||
with open(YAML_PATH, 'w') as crowdin_config_file:
|
||||
crowdin_config_file.write(crowdin_config)
|
||||
raise e
|
|
@ -0,0 +1,30 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
with open('intl/upload_workflow.py', 'r') as workflow:
|
||||
workflow_config = workflow.read()
|
||||
|
||||
workflow_config = workflow_config.replace(
|
||||
"subprocess.run(['python3', 'intl/core_option_translation.py', dir_path, core_name])",
|
||||
"subprocess.run(['python3', 'intl/crowdin_prep.py', dir_path, core_name])"
|
||||
)
|
||||
workflow_config = workflow_config.replace(
|
||||
"subprocess.run(['python3', 'intl/initial_sync.py', api_key, core_name])",
|
||||
"subprocess.run(['python3', 'intl/crowdin_source_upload.py', api_key, core_name])"
|
||||
)
|
||||
with open('intl/upload_workflow.py', 'w') as workflow:
|
||||
workflow.write(workflow_config)
|
||||
|
||||
|
||||
with open('intl/download_workflow.py', 'r') as workflow:
|
||||
workflow_config = workflow.read()
|
||||
|
||||
workflow_config = workflow_config.replace(
|
||||
"subprocess.run(['python3', 'intl/core_option_translation.py', dir_path, core_name])",
|
||||
"subprocess.run(['python3', 'intl/crowdin_prep.py', dir_path, core_name])"
|
||||
)
|
||||
workflow_config = workflow_config.replace(
|
||||
"subprocess.run(['python3', 'intl/initial_sync.py', api_key, core_name])",
|
||||
"subprocess.run(['python3', 'intl/crowdin_translation_download.py', api_key, core_name])"
|
||||
)
|
||||
with open('intl/download_workflow.py', 'w') as workflow:
|
||||
workflow.write(workflow_config)
|
|
@ -0,0 +1,15 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
import sys
|
||||
import subprocess
|
||||
|
||||
try:
|
||||
api_key = sys.argv[1]
|
||||
core_name = sys.argv[2]
|
||||
dir_path = sys.argv[3]
|
||||
except IndexError as e:
|
||||
print('Please provide path to libretro_core_options.h, Crowdin API Token and core name!')
|
||||
raise e
|
||||
|
||||
subprocess.run(['python3', 'intl/crowdin_prep.py', dir_path, core_name])
|
||||
subprocess.run(['python3', 'intl/crowdin_source_upload.py', api_key, core_name])
|
|
@ -0,0 +1,476 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
"""Core options v1 to v2 converter
|
||||
|
||||
Just run this script as follows, to convert 'libretro_core_options.h' & 'Libretro_coreoptions_intl.h' to v2:
|
||||
python3 "/path/to/v1_to_v2_converter.py" "/path/to/where/libretro_core_options.h & Libretro_coreoptions_intl.h/are"
|
||||
|
||||
The original files will be preserved as *.v1
|
||||
"""
|
||||
import core_option_regex as cor
|
||||
import os
|
||||
import sys
|
||||
import glob
|
||||
|
||||
|
||||
def create_v2_code_file(struct_text, file_name):
|
||||
def replace_option(option_match):
|
||||
_offset = option_match.start(0)
|
||||
|
||||
if option_match.group(3):
|
||||
res = option_match.group(0)[:option_match.end(2) - _offset] + ',\n NULL' + \
|
||||
option_match.group(0)[option_match.end(2) - _offset:option_match.end(3) - _offset] + \
|
||||
'NULL,\n NULL,\n ' + option_match.group(0)[option_match.end(3) - _offset:]
|
||||
else:
|
||||
return option_match.group(0)
|
||||
|
||||
return res
|
||||
|
||||
comment_v1 = '/*\n' \
|
||||
' ********************************\n' \
|
||||
' * VERSION: 1.3\n' \
|
||||
' ********************************\n' \
|
||||
' *\n' \
|
||||
' * - 1.3: Move translations to libretro_core_options_intl.h\n' \
|
||||
' * - libretro_core_options_intl.h includes BOM and utf-8\n' \
|
||||
' * fix for MSVC 2010-2013\n' \
|
||||
' * - Added HAVE_NO_LANGEXTRA flag to disable translations\n' \
|
||||
' * on platforms/compilers without BOM support\n' \
|
||||
' * - 1.2: Use core options v1 interface when\n' \
|
||||
' * RETRO_ENVIRONMENT_GET_CORE_OPTIONS_VERSION is >= 1\n' \
|
||||
' * (previously required RETRO_ENVIRONMENT_GET_CORE_OPTIONS_VERSION == 1)\n' \
|
||||
' * - 1.1: Support generation of core options v0 retro_core_option_value\n' \
|
||||
' * arrays containing options with a single value\n' \
|
||||
' * - 1.0: First commit\n' \
|
||||
'*/\n'
|
||||
|
||||
comment_v2 = '/*\n' \
|
||||
' ********************************\n' \
|
||||
' * VERSION: 2.0\n' \
|
||||
' ********************************\n' \
|
||||
' *\n' \
|
||||
' * - 2.0: Add support for core options v2 interface\n' \
|
||||
' * - 1.3: Move translations to libretro_core_options_intl.h\n' \
|
||||
' * - libretro_core_options_intl.h includes BOM and utf-8\n' \
|
||||
' * fix for MSVC 2010-2013\n' \
|
||||
' * - Added HAVE_NO_LANGEXTRA flag to disable translations\n' \
|
||||
' * on platforms/compilers without BOM support\n' \
|
||||
' * - 1.2: Use core options v1 interface when\n' \
|
||||
' * RETRO_ENVIRONMENT_GET_CORE_OPTIONS_VERSION is >= 1\n' \
|
||||
' * (previously required RETRO_ENVIRONMENT_GET_CORE_OPTIONS_VERSION == 1)\n' \
|
||||
' * - 1.1: Support generation of core options v0 retro_core_option_value\n' \
|
||||
' * arrays containing options with a single value\n' \
|
||||
' * - 1.0: First commit\n' \
|
||||
'*/\n'
|
||||
|
||||
p_intl = cor.p_intl
|
||||
p_set = cor.p_set
|
||||
new_set = 'static INLINE void libretro_set_core_options(retro_environment_t environ_cb,\n' \
|
||||
' bool *categories_supported)\n' \
|
||||
'{\n' \
|
||||
' unsigned version = 0;\n' \
|
||||
'#ifndef HAVE_NO_LANGEXTRA\n' \
|
||||
' unsigned language = 0;\n' \
|
||||
'#endif\n' \
|
||||
'\n' \
|
||||
' if (!environ_cb || !categories_supported)\n' \
|
||||
' return;\n' \
|
||||
'\n' \
|
||||
' *categories_supported = false;\n' \
|
||||
'\n' \
|
||||
' if (!environ_cb(RETRO_ENVIRONMENT_GET_CORE_OPTIONS_VERSION, &version))\n' \
|
||||
' version = 0;\n' \
|
||||
'\n' \
|
||||
' if (version >= 2)\n' \
|
||||
' {\n' \
|
||||
'#ifndef HAVE_NO_LANGEXTRA\n' \
|
||||
' struct retro_core_options_v2_intl core_options_intl;\n' \
|
||||
'\n' \
|
||||
' core_options_intl.us = &options_us;\n' \
|
||||
' core_options_intl.local = NULL;\n' \
|
||||
'\n' \
|
||||
' if (environ_cb(RETRO_ENVIRONMENT_GET_LANGUAGE, &language) &&\n' \
|
||||
' (language < RETRO_LANGUAGE_LAST) && (language != RETRO_LANGUAGE_ENGLISH))\n' \
|
||||
' core_options_intl.local = options_intl[language];\n' \
|
||||
'\n' \
|
||||
' *categories_supported = environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_V2_INTL,\n' \
|
||||
' &core_options_intl);\n' \
|
||||
'#else\n' \
|
||||
' *categories_supported = environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_V2,\n' \
|
||||
' &options_us);\n' \
|
||||
'#endif\n' \
|
||||
' }\n' \
|
||||
' else\n' \
|
||||
' {\n' \
|
||||
' size_t i, j;\n' \
|
||||
' size_t option_index = 0;\n' \
|
||||
' size_t num_options = 0;\n' \
|
||||
' struct retro_core_option_definition\n' \
|
||||
' *option_v1_defs_us = NULL;\n' \
|
||||
'#ifndef HAVE_NO_LANGEXTRA\n' \
|
||||
' size_t num_options_intl = 0;\n' \
|
||||
' struct retro_core_option_v2_definition\n' \
|
||||
' *option_defs_intl = NULL;\n' \
|
||||
' struct retro_core_option_definition\n' \
|
||||
' *option_v1_defs_intl = NULL;\n' \
|
||||
' struct retro_core_options_intl\n' \
|
||||
' core_options_v1_intl;\n' \
|
||||
'#endif\n' \
|
||||
' struct retro_variable *variables = NULL;\n' \
|
||||
' char **values_buf = NULL;\n' \
|
||||
'\n' \
|
||||
' /* Determine total number of options */\n' \
|
||||
' while (true)\n' \
|
||||
' {\n' \
|
||||
' if (option_defs_us[num_options].key)\n' \
|
||||
' num_options++;\n' \
|
||||
' else\n' \
|
||||
' break;\n' \
|
||||
' }\n' \
|
||||
'\n' \
|
||||
' if (version >= 1)\n' \
|
||||
' {\n' \
|
||||
' /* Allocate US array */\n' \
|
||||
' option_v1_defs_us = (struct retro_core_option_definition *)\n' \
|
||||
' calloc(num_options + 1, sizeof(struct retro_core_option_definition));\n' \
|
||||
'\n' \
|
||||
' /* Copy parameters from option_defs_us array */\n' \
|
||||
' for (i = 0; i < num_options; i++)\n' \
|
||||
' {\n' \
|
||||
' struct retro_core_option_v2_definition *option_def_us = &option_defs_us[i];\n' \
|
||||
' struct retro_core_option_value *option_values = option_def_us->values;\n' \
|
||||
' struct retro_core_option_definition *option_v1_def_us = &option_v1_defs_us[i];\n' \
|
||||
' struct retro_core_option_value *option_v1_values = option_v1_def_us->values;\n' \
|
||||
'\n' \
|
||||
' option_v1_def_us->key = option_def_us->key;\n' \
|
||||
' option_v1_def_us->desc = option_def_us->desc;\n' \
|
||||
' option_v1_def_us->info = option_def_us->info;\n' \
|
||||
' option_v1_def_us->default_value = option_def_us->default_value;\n' \
|
||||
'\n' \
|
||||
' /* Values must be copied individually... */\n' \
|
||||
' while (option_values->value)\n' \
|
||||
' {\n' \
|
||||
' option_v1_values->value = option_values->value;\n' \
|
||||
' option_v1_values->label = option_values->label;\n' \
|
||||
'\n' \
|
||||
' option_values++;\n' \
|
||||
' option_v1_values++;\n' \
|
||||
' }\n' \
|
||||
' }\n' \
|
||||
'\n' \
|
||||
'#ifndef HAVE_NO_LANGEXTRA\n' \
|
||||
' if (environ_cb(RETRO_ENVIRONMENT_GET_LANGUAGE, &language) &&\n' \
|
||||
' (language < RETRO_LANGUAGE_LAST) && (language != RETRO_LANGUAGE_ENGLISH) &&\n' \
|
||||
' options_intl[language])\n' \
|
||||
' option_defs_intl = options_intl[language]->definitions;\n' \
|
||||
'\n' \
|
||||
' if (option_defs_intl)\n' \
|
||||
' {\n' \
|
||||
' /* Determine number of intl options */\n' \
|
||||
' while (true)\n' \
|
||||
' {\n' \
|
||||
' if (option_defs_intl[num_options_intl].key)\n' \
|
||||
' num_options_intl++;\n' \
|
||||
' else\n' \
|
||||
' break;\n' \
|
||||
' }\n' \
|
||||
'\n' \
|
||||
' /* Allocate intl array */\n' \
|
||||
' option_v1_defs_intl = (struct retro_core_option_definition *)\n' \
|
||||
' calloc(num_options_intl + 1, sizeof(struct retro_core_option_definition));\n' \
|
||||
'\n' \
|
||||
' /* Copy parameters from option_defs_intl array */\n' \
|
||||
' for (i = 0; i < num_options_intl; i++)\n' \
|
||||
' {\n' \
|
||||
' struct retro_core_option_v2_definition *option_def_intl = &option_defs_intl[i];\n' \
|
||||
' struct retro_core_option_value *option_values = option_def_intl->values;\n' \
|
||||
' struct retro_core_option_definition *option_v1_def_intl = &option_v1_defs_intl[i];\n' \
|
||||
' struct retro_core_option_value *option_v1_values = option_v1_def_intl->values;\n' \
|
||||
'\n' \
|
||||
' option_v1_def_intl->key = option_def_intl->key;\n' \
|
||||
' option_v1_def_intl->desc = option_def_intl->desc;\n' \
|
||||
' option_v1_def_intl->info = option_def_intl->info;\n' \
|
||||
' option_v1_def_intl->default_value = option_def_intl->default_value;\n' \
|
||||
'\n' \
|
||||
' /* Values must be copied individually... */\n' \
|
||||
' while (option_values->value)\n' \
|
||||
' {\n' \
|
||||
' option_v1_values->value = option_values->value;\n' \
|
||||
' option_v1_values->label = option_values->label;\n' \
|
||||
'\n' \
|
||||
' option_values++;\n' \
|
||||
' option_v1_values++;\n' \
|
||||
' }\n' \
|
||||
' }\n' \
|
||||
' }\n' \
|
||||
'\n' \
|
||||
' core_options_v1_intl.us = option_v1_defs_us;\n' \
|
||||
' core_options_v1_intl.local = option_v1_defs_intl;\n' \
|
||||
'\n' \
|
||||
' environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_INTL, &core_options_v1_intl);\n' \
|
||||
'#else\n' \
|
||||
' environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS, option_v1_defs_us);\n' \
|
||||
'#endif\n' \
|
||||
' }\n' \
|
||||
' else\n' \
|
||||
' {\n' \
|
||||
' /* Allocate arrays */\n' \
|
||||
' variables = (struct retro_variable *)calloc(num_options + 1,\n' \
|
||||
' sizeof(struct retro_variable));\n' \
|
||||
' values_buf = (char **)calloc(num_options, sizeof(char *));\n' \
|
||||
'\n' \
|
||||
' if (!variables || !values_buf)\n' \
|
||||
' goto error;\n' \
|
||||
'\n' \
|
||||
' /* Copy parameters from option_defs_us array */\n' \
|
||||
' for (i = 0; i < num_options; i++)\n' \
|
||||
' {\n' \
|
||||
' const char *key = option_defs_us[i].key;\n' \
|
||||
' const char *desc = option_defs_us[i].desc;\n' \
|
||||
' const char *default_value = option_defs_us[i].default_value;\n' \
|
||||
' struct retro_core_option_value *values = option_defs_us[i].values;\n' \
|
||||
' size_t buf_len = 3;\n' \
|
||||
' size_t default_index = 0;\n' \
|
||||
'\n' \
|
||||
' values_buf[i] = NULL;\n' \
|
||||
'\n' \
|
||||
' if (desc)\n' \
|
||||
' {\n' \
|
||||
' size_t num_values = 0;\n' \
|
||||
'\n' \
|
||||
' /* Determine number of values */\n' \
|
||||
' while (true)\n' \
|
||||
' {\n' \
|
||||
' if (values[num_values].value)\n' \
|
||||
' {\n' \
|
||||
' /* Check if this is the default value */\n' \
|
||||
' if (default_value)\n' \
|
||||
' if (strcmp(values[num_values].value, default_value) == 0)\n' \
|
||||
' default_index = num_values;\n' \
|
||||
'\n' \
|
||||
' buf_len += strlen(values[num_values].value);\n' \
|
||||
' num_values++;\n' \
|
||||
' }\n' \
|
||||
' else\n' \
|
||||
' break;\n' \
|
||||
' }\n' \
|
||||
'\n' \
|
||||
' /* Build values string */\n' \
|
||||
' if (num_values > 0)\n' \
|
||||
' {\n' \
|
||||
' buf_len += num_values - 1;\n' \
|
||||
' buf_len += strlen(desc);\n' \
|
||||
'\n' \
|
||||
' values_buf[i] = (char *)calloc(buf_len, sizeof(char));\n' \
|
||||
' if (!values_buf[i])\n' \
|
||||
' goto error;\n' \
|
||||
'\n' \
|
||||
' strcpy(values_buf[i], desc);\n' \
|
||||
' strcat(values_buf[i], "; ");\n' \
|
||||
'\n' \
|
||||
' /* Default value goes first */\n' \
|
||||
' strcat(values_buf[i], values[default_index].value);\n' \
|
||||
'\n' \
|
||||
' /* Add remaining values */\n' \
|
||||
' for (j = 0; j < num_values; j++)\n' \
|
||||
' {\n' \
|
||||
' if (j != default_index)\n' \
|
||||
' {\n' \
|
||||
' strcat(values_buf[i], "|");\n' \
|
||||
' strcat(values_buf[i], values[j].value);\n' \
|
||||
' }\n' \
|
||||
' }\n' \
|
||||
' }\n' \
|
||||
' }\n' \
|
||||
'\n' \
|
||||
' variables[option_index].key = key;\n' \
|
||||
' variables[option_index].value = values_buf[i];\n' \
|
||||
' option_index++;\n' \
|
||||
' }\n' \
|
||||
'\n' \
|
||||
' /* Set variables */\n' \
|
||||
' environ_cb(RETRO_ENVIRONMENT_SET_VARIABLES, variables);\n' \
|
||||
' }\n' \
|
||||
'\n' \
|
||||
'error:\n' \
|
||||
' /* Clean up */\n' \
|
||||
'\n' \
|
||||
' if (option_v1_defs_us)\n' \
|
||||
' {\n' \
|
||||
' free(option_v1_defs_us);\n' \
|
||||
' option_v1_defs_us = NULL;\n' \
|
||||
' }\n' \
|
||||
'\n' \
|
||||
'#ifndef HAVE_NO_LANGEXTRA\n' \
|
||||
' if (option_v1_defs_intl)\n' \
|
||||
' {\n' \
|
||||
' free(option_v1_defs_intl);\n' \
|
||||
' option_v1_defs_intl = NULL;\n' \
|
||||
' }\n' \
|
||||
'#endif\n' \
|
||||
'\n' \
|
||||
' if (values_buf)\n' \
|
||||
' {\n' \
|
||||
' for (i = 0; i < num_options; i++)\n' \
|
||||
' {\n' \
|
||||
' if (values_buf[i])\n' \
|
||||
' {\n' \
|
||||
' free(values_buf[i]);\n' \
|
||||
' values_buf[i] = NULL;\n' \
|
||||
' }\n' \
|
||||
' }\n' \
|
||||
'\n' \
|
||||
' free(values_buf);\n' \
|
||||
' values_buf = NULL;\n' \
|
||||
' }\n' \
|
||||
'\n' \
|
||||
' if (variables)\n' \
|
||||
' {\n' \
|
||||
' free(variables);\n' \
|
||||
' variables = NULL;\n' \
|
||||
' }\n' \
|
||||
' }\n' \
|
||||
'}\n' \
|
||||
'\n' \
|
||||
'#ifdef __cplusplus\n' \
|
||||
'}\n' \
|
||||
'#endif'
|
||||
|
||||
struct_groups = cor.p_struct.finditer(struct_text)
|
||||
out_text = struct_text
|
||||
|
||||
for construct in struct_groups:
|
||||
repl_text = ''
|
||||
declaration = construct.group(1)
|
||||
struct_match = cor.p_type_name.search(declaration)
|
||||
if struct_match:
|
||||
if struct_match.group(3):
|
||||
struct_type_name_lang = struct_match.group(1, 2, 3)
|
||||
declaration_end = declaration[struct_match.end(1):]
|
||||
elif struct_match.group(4):
|
||||
struct_type_name_lang = struct_match.group(1, 2, 4)
|
||||
declaration_end = declaration[struct_match.end(1):]
|
||||
else:
|
||||
struct_type_name_lang = sum((struct_match.group(1, 2), ('_us',)), ())
|
||||
declaration_end = f'{declaration[struct_match.end(1):struct_match.end(2)]}_us' \
|
||||
f'{declaration[struct_match.end(2):]}'
|
||||
else:
|
||||
return -1
|
||||
|
||||
if 'retro_core_option_definition' == struct_type_name_lang[0]:
|
||||
import shutil
|
||||
shutil.copy(file_name, file_name + '.v1')
|
||||
new_declaration = f'\nstruct retro_core_option_v2_category option_cats{struct_type_name_lang[2]}[] = ' \
|
||||
'{\n { NULL, NULL, NULL },\n' \
|
||||
'};\n\n' \
|
||||
+ declaration[:struct_match.start(1)] + \
|
||||
'retro_core_option_v2_definition' \
|
||||
+ declaration_end
|
||||
offset = construct.start(0)
|
||||
repl_text = repl_text + cor.re.sub(cor.re.escape(declaration), new_declaration,
|
||||
construct.group(0)[:construct.start(2) - offset])
|
||||
content = construct.group(2)
|
||||
new_content = cor.p_option.sub(replace_option, content)
|
||||
|
||||
repl_text = repl_text + new_content + cor.re.sub(r'{\s*NULL,\s*NULL,\s*NULL,\s*{\{0}},\s*NULL\s*},\s*};',
|
||||
'{ NULL, NULL, NULL, NULL, NULL, NULL, {{0}}, NULL },\n};'
|
||||
'\n\nstruct retro_core_options_v2 options' +
|
||||
struct_type_name_lang[2] + ' = {\n'
|
||||
f' option_cats{struct_type_name_lang[2]},\n'
|
||||
f' option_defs{struct_type_name_lang[2]}\n'
|
||||
'};',
|
||||
construct.group(0)[construct.end(2) - offset:])
|
||||
out_text = cor.re.sub(cor.re.escape(construct.group(0)), repl_text, out_text)
|
||||
else:
|
||||
return -2
|
||||
with open(file_name, 'w', encoding='utf-8') as code_file:
|
||||
out_text = cor.re.sub(cor.re.escape(comment_v1), comment_v2, out_text)
|
||||
intl = p_intl.search(out_text)
|
||||
if intl:
|
||||
new_intl = out_text[:intl.start(1)] \
|
||||
+ 'struct retro_core_options_v2 *options_intl[RETRO_LANGUAGE_LAST]' \
|
||||
+ out_text[intl.end(1):intl.start(2)] \
|
||||
+ '\n &options_us, /* RETRO_LANGUAGE_ENGLISH */\n' \
|
||||
' &options_ja, /* RETRO_LANGUAGE_JAPANESE */\n' \
|
||||
' &options_fr, /* RETRO_LANGUAGE_FRENCH */\n' \
|
||||
' &options_es, /* RETRO_LANGUAGE_SPANISH */\n' \
|
||||
' &options_de, /* RETRO_LANGUAGE_GERMAN */\n' \
|
||||
' &options_it, /* RETRO_LANGUAGE_ITALIAN */\n' \
|
||||
' &options_nl, /* RETRO_LANGUAGE_DUTCH */\n' \
|
||||
' &options_pt_br, /* RETRO_LANGUAGE_PORTUGUESE_BRAZIL */\n' \
|
||||
' &options_pt_pt, /* RETRO_LANGUAGE_PORTUGUESE_PORTUGAL */\n' \
|
||||
' &options_ru, /* RETRO_LANGUAGE_RUSSIAN */\n' \
|
||||
' &options_ko, /* RETRO_LANGUAGE_KOREAN */\n' \
|
||||
' &options_cht, /* RETRO_LANGUAGE_CHINESE_TRADITIONAL */\n' \
|
||||
' &options_chs, /* RETRO_LANGUAGE_CHINESE_SIMPLIFIED */\n' \
|
||||
' &options_eo, /* RETRO_LANGUAGE_ESPERANTO */\n' \
|
||||
' &options_pl, /* RETRO_LANGUAGE_POLISH */\n' \
|
||||
' &options_vn, /* RETRO_LANGUAGE_VIETNAMESE */\n' \
|
||||
' &options_ar, /* RETRO_LANGUAGE_ARABIC */\n' \
|
||||
' &options_el, /* RETRO_LANGUAGE_GREEK */\n' \
|
||||
' &options_tr, /* RETRO_LANGUAGE_TURKISH */\n' \
|
||||
' &options_sv, /* RETRO_LANGUAGE_SLOVAK */\n' \
|
||||
' &options_fa, /* RETRO_LANGUAGE_PERSIAN */\n' \
|
||||
' &options_he, /* RETRO_LANGUAGE_HEBREW */\n' \
|
||||
' &options_ast, /* RETRO_LANGUAGE_ASTURIAN */\n' \
|
||||
' &options_fi, /* RETRO_LANGUAGE_FINNISH */\n' \
|
||||
+ out_text[intl.end(2):]
|
||||
out_text = p_set.sub(new_set, new_intl)
|
||||
else:
|
||||
out_text = p_set.sub(new_set, out_text)
|
||||
code_file.write(out_text)
|
||||
|
||||
return 1
|
||||
|
||||
|
||||
# -------------------- MAIN -------------------- #
|
||||
|
||||
if __name__ == '__main__':
|
||||
DIR_PATH = os.path.dirname(os.path.realpath(__file__))
|
||||
if os.path.basename(DIR_PATH) != "intl":
|
||||
raise RuntimeError("Script is not in intl folder!")
|
||||
|
||||
BASE_PATH = os.path.dirname(DIR_PATH)
|
||||
CORE_OP_FILE = os.path.join(BASE_PATH, "**", "libretro_core_options.h")
|
||||
|
||||
core_options_hits = glob.glob(CORE_OP_FILE, recursive=True)
|
||||
|
||||
if len(core_options_hits) == 0:
|
||||
raise RuntimeError("libretro_core_options.h not found!")
|
||||
elif len(core_options_hits) > 1:
|
||||
print("More than one libretro_core_options.h file found:\n\n")
|
||||
for i, file in enumerate(core_options_hits):
|
||||
print(f"{i} {file}\n")
|
||||
|
||||
while True:
|
||||
user_choice = input("Please choose one ('q' will exit): ")
|
||||
if user_choice == 'q':
|
||||
exit(0)
|
||||
elif user_choice.isdigit():
|
||||
core_op_file = core_options_hits[int(user_choice)]
|
||||
break
|
||||
else:
|
||||
print("Please make a valid choice!\n\n")
|
||||
else:
|
||||
core_op_file = core_options_hits[0]
|
||||
|
||||
H_FILE_PATH = core_op_file
|
||||
INTL_FILE_PATH = core_op_file.replace("libretro_core_options.h", 'libretro_core_options_intl.h')
|
||||
|
||||
for file in (H_FILE_PATH, INTL_FILE_PATH):
|
||||
if os.path.isfile(file):
|
||||
with open(file, 'r+', encoding='utf-8') as h_file:
|
||||
text = h_file.read()
|
||||
try:
|
||||
test = create_v2_code_file(text, file)
|
||||
except Exception as e:
|
||||
print(e)
|
||||
test = -1
|
||||
if -1 > test:
|
||||
print('Your file looks like it already is v2? (' + file + ')')
|
||||
continue
|
||||
if 0 > test:
|
||||
print('An error occured! Please make sure to use the complete v1 struct! (' + file + ')')
|
||||
continue
|
||||
else:
|
||||
print(file + ' not found.')
|
|
@ -21,24 +21,124 @@
|
|||
|
||||
#include <libretro.h>
|
||||
|
||||
#define SAMPLE_COUNT 512
|
||||
struct SoundFrame { s16 l; s16 r; };
|
||||
#include <vector>
|
||||
#include <mutex>
|
||||
|
||||
#define AUDIO_BUFFER_SIZE_DEFAULT (1 << 11)
|
||||
#define AUDIO_BUFFER_SIZE_MAX (1 << 20) /* 1 MiB */
|
||||
|
||||
extern retro_audio_sample_batch_t audio_batch_cb;
|
||||
|
||||
static std::mutex audio_buffer_mutex;
|
||||
static std::vector<int16_t> audio_buffer;
|
||||
static size_t audio_buffer_idx;
|
||||
static size_t audio_batch_frames_max;
|
||||
|
||||
static int16_t *audio_out_buffer = nullptr;
|
||||
static size_t audio_out_buffer_size;
|
||||
|
||||
void retro_audio_init(void)
|
||||
{
|
||||
const std::lock_guard<std::mutex> lock(audio_buffer_mutex);
|
||||
|
||||
audio_buffer.resize(AUDIO_BUFFER_SIZE_DEFAULT);
|
||||
audio_buffer_idx = 0;
|
||||
audio_batch_frames_max = std::numeric_limits<size_t>::max();
|
||||
|
||||
audio_out_buffer_size = AUDIO_BUFFER_SIZE_DEFAULT;
|
||||
audio_out_buffer = (int16_t*)malloc(audio_out_buffer_size * sizeof(int16_t));
|
||||
}
|
||||
|
||||
void retro_audio_deinit(void)
|
||||
{
|
||||
const std::lock_guard<std::mutex> lock(audio_buffer_mutex);
|
||||
|
||||
audio_buffer.clear();
|
||||
audio_buffer_idx = 0;
|
||||
|
||||
if (audio_out_buffer != nullptr)
|
||||
free(audio_out_buffer);
|
||||
|
||||
audio_out_buffer = nullptr;
|
||||
audio_out_buffer_size = 0;
|
||||
}
|
||||
|
||||
void retro_audio_flush_buffer(void)
|
||||
{
|
||||
const std::lock_guard<std::mutex> lock(audio_buffer_mutex);
|
||||
audio_buffer_idx = 0;
|
||||
}
|
||||
|
||||
void retro_audio_upload(void)
|
||||
{
|
||||
audio_buffer_mutex.lock();
|
||||
|
||||
if (audio_out_buffer_size < audio_buffer_idx)
|
||||
{
|
||||
int16_t *tmp = (int16_t *)realloc(audio_out_buffer,
|
||||
audio_buffer_idx * sizeof(int16_t));
|
||||
|
||||
if (!tmp)
|
||||
{
|
||||
audio_buffer_idx = 0;
|
||||
audio_buffer_mutex.unlock();
|
||||
return;
|
||||
}
|
||||
|
||||
audio_out_buffer_size = audio_buffer_idx;
|
||||
audio_out_buffer = tmp;
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < audio_buffer_idx; i++)
|
||||
audio_out_buffer[i] = audio_buffer[i];
|
||||
|
||||
size_t num_frames = audio_buffer_idx >> 1;
|
||||
audio_buffer_idx = 0;
|
||||
|
||||
audio_buffer_mutex.unlock();
|
||||
|
||||
int16_t *audio_out_buffer_ptr = audio_out_buffer;
|
||||
while (num_frames > 0)
|
||||
{
|
||||
size_t frames_to_write = (num_frames > audio_batch_frames_max) ?
|
||||
audio_batch_frames_max : num_frames;
|
||||
size_t frames_written = audio_batch_cb(audio_out_buffer_ptr,
|
||||
frames_to_write);
|
||||
|
||||
if ((frames_written < frames_to_write) &&
|
||||
(frames_written > 0))
|
||||
audio_batch_frames_max = frames_written;
|
||||
|
||||
num_frames -= frames_to_write;
|
||||
audio_out_buffer_ptr += frames_to_write << 1;
|
||||
}
|
||||
}
|
||||
|
||||
void WriteSample(s16 r, s16 l)
|
||||
{
|
||||
static SoundFrame Buffer[SAMPLE_COUNT];
|
||||
static u32 writePtr; // next sample index
|
||||
Buffer[writePtr].r = r;
|
||||
Buffer[writePtr].l = l;
|
||||
const std::lock_guard<std::mutex> lock(audio_buffer_mutex);
|
||||
|
||||
if (++writePtr == SAMPLE_COUNT)
|
||||
{
|
||||
if (emu.running() && (!config::ThreadedRendering || config::LimitFPS))
|
||||
audio_batch_cb((const int16_t*)Buffer, SAMPLE_COUNT);
|
||||
writePtr = 0;
|
||||
}
|
||||
if (audio_buffer.size() < audio_buffer_idx + 2)
|
||||
{
|
||||
if (audio_buffer_idx + 2 > AUDIO_BUFFER_SIZE_MAX)
|
||||
{
|
||||
audio_buffer_idx = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
audio_buffer.resize(audio_buffer_idx + 2 + AUDIO_BUFFER_SIZE_DEFAULT);
|
||||
}
|
||||
catch (std::bad_alloc &)
|
||||
{
|
||||
audio_buffer_idx = 0;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
audio_buffer[audio_buffer_idx++] = l;
|
||||
audio_buffer[audio_buffer_idx++] = r;
|
||||
}
|
||||
|
||||
void InitAudio()
|
||||
|
|
|
@ -77,13 +77,6 @@ constexpr char slash = path_default_slash_c();
|
|||
* background or not.
|
||||
*/
|
||||
|
||||
#define RETRO_ENVIRONMENT_GET_CLEAR_ALL_THREAD_WAITS_CB (3 | RETRO_ENVIRONMENT_RETROARCH_START_BLOCK)
|
||||
/* retro_environment_t * --
|
||||
* Provides the callback to the frontend method which will cancel
|
||||
* all currently waiting threads. Used when coordination is needed
|
||||
* between the core and the frontend to gracefully stop all threads.
|
||||
*/
|
||||
|
||||
#define RETRO_ENVIRONMENT_POLL_TYPE_OVERRIDE (4 | RETRO_ENVIRONMENT_RETROARCH_START_BLOCK)
|
||||
/* unsigned * --
|
||||
* Tells the frontend to override the poll type behavior.
|
||||
|
@ -102,6 +95,11 @@ constexpr char slash = path_default_slash_c();
|
|||
#include "libretro_core_options.h"
|
||||
#include "vmu_xhair.h"
|
||||
|
||||
extern void retro_audio_init(void);
|
||||
extern void retro_audio_deinit(void);
|
||||
extern void retro_audio_flush_buffer(void);
|
||||
extern void retro_audio_upload(void);
|
||||
|
||||
std::string arcadeFlashPath;
|
||||
static bool boot_to_bios;
|
||||
|
||||
|
@ -114,6 +112,8 @@ static bool allow_service_buttons = false;
|
|||
|
||||
static bool libretro_supports_bitmasks = false;
|
||||
|
||||
static bool categoriesSupported = false;
|
||||
|
||||
u32 kcode[4] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
|
||||
u8 rt[4];
|
||||
u8 lt[4];
|
||||
|
@ -161,7 +161,6 @@ static retro_input_poll_t poll_cb;
|
|||
static retro_input_state_t input_cb;
|
||||
retro_audio_sample_batch_t audio_batch_cb;
|
||||
static retro_environment_t environ_cb;
|
||||
static retro_environment_t frontend_clear_thread_waits_cb;
|
||||
|
||||
static retro_rumble_interface rumble;
|
||||
|
||||
|
@ -235,7 +234,7 @@ void retro_set_environment(retro_environment_t cb)
|
|||
{
|
||||
environ_cb = cb;
|
||||
|
||||
libretro_set_core_options(environ_cb);
|
||||
libretro_set_core_options(environ_cb, &categoriesSupported);
|
||||
|
||||
static const struct retro_controller_description ports_default[] =
|
||||
{
|
||||
|
@ -281,8 +280,6 @@ void retro_init()
|
|||
unsigned color_mode = RETRO_PIXEL_FORMAT_XRGB8888;
|
||||
environ_cb(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &color_mode);
|
||||
|
||||
environ_cb(RETRO_ENVIRONMENT_GET_CLEAR_ALL_THREAD_WAITS_CB, &frontend_clear_thread_waits_cb);
|
||||
|
||||
init_kb_map();
|
||||
struct retro_keyboard_callback kb_callback = { &retro_keyboard_event };
|
||||
environ_cb(RETRO_ENVIRONMENT_SET_KEYBOARD_CALLBACK, &kb_callback);
|
||||
|
@ -291,6 +288,7 @@ void retro_init()
|
|||
libretro_supports_bitmasks = true;
|
||||
|
||||
init_disk_control_interface();
|
||||
retro_audio_init();
|
||||
|
||||
if (!_vmem_reserve())
|
||||
ERROR_LOG(VMEM, "Cannot reserve memory space");
|
||||
|
@ -312,6 +310,8 @@ void retro_deinit()
|
|||
os_UninstallFaultHandler();
|
||||
libretro_supports_bitmasks = false;
|
||||
LogManager::Shutdown();
|
||||
|
||||
retro_audio_deinit();
|
||||
}
|
||||
|
||||
static void set_variable_visibility()
|
||||
|
@ -349,6 +349,10 @@ static void set_variable_visibility()
|
|||
environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_DISPLAY, &option_display);
|
||||
option_display.key = CORE_OPTION_NAME "_per_content_vmus";
|
||||
environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_DISPLAY, &option_display);
|
||||
|
||||
/* only show, if categories not supported */
|
||||
option_display.visible = ((settings.platform.system == DC_PLATFORM_DREAMCAST)
|
||||
&& (!categoriesSupported));
|
||||
option_display.key = CORE_OPTION_NAME "_show_vmu_screen_settings";
|
||||
environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_DISPLAY, &option_display);
|
||||
|
||||
|
@ -374,7 +378,9 @@ static void set_variable_visibility()
|
|||
option_display.visible = true;
|
||||
var.key = CORE_OPTION_NAME "_show_vmu_screen_settings";
|
||||
|
||||
if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
|
||||
if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var)
|
||||
&& var.value
|
||||
&& !categoriesSupported)
|
||||
if (!strcmp(var.value, "disabled"))
|
||||
option_display.visible = false;
|
||||
}
|
||||
|
@ -400,11 +406,18 @@ static void set_variable_visibility()
|
|||
environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_DISPLAY, &option_display);
|
||||
}
|
||||
|
||||
/* only show, if categories not supported */
|
||||
option_display.visible = !categoriesSupported;
|
||||
option_display.key = CORE_OPTION_NAME "_show_lightgun_settings";
|
||||
environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_DISPLAY, &option_display);
|
||||
|
||||
// Show/hide light gun options
|
||||
option_display.visible = true;
|
||||
var.key = CORE_OPTION_NAME "_show_lightgun_settings";
|
||||
|
||||
if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
|
||||
if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var)
|
||||
&& var.value
|
||||
&& !categoriesSupported)
|
||||
if (!strcmp(var.value, "disabled"))
|
||||
option_display.visible = false;
|
||||
|
||||
|
@ -885,6 +898,11 @@ void retro_run()
|
|||
if (isOpenGL(config::RendererType))
|
||||
glsm_ctl(GLSM_CTL_STATE_UNBIND, nullptr);
|
||||
|
||||
if (!config::ThreadedRendering || config::LimitFPS)
|
||||
retro_audio_upload();
|
||||
else
|
||||
retro_audio_flush_buffer();
|
||||
|
||||
video_cb(is_dupe ? 0 : RETRO_HW_FRAME_BUFFER_VALID, framebufferWidth, framebufferHeight, 0);
|
||||
}
|
||||
|
||||
|
@ -918,6 +936,7 @@ void retro_reset()
|
|||
setGameGeometry(geometry);
|
||||
environ_cb(RETRO_ENVIRONMENT_SET_GEOMETRY, &geometry);
|
||||
blankVmus();
|
||||
retro_audio_flush_buffer();
|
||||
|
||||
emu.start();
|
||||
}
|
||||
|
@ -1435,11 +1454,6 @@ static bool set_opengl_hw_render(u32 preferred)
|
|||
params.context_reset = context_reset;
|
||||
params.context_destroy = context_destroy;
|
||||
params.environ_cb = environ_cb;
|
||||
#ifdef TARGET_NO_STENCIL
|
||||
params.stencil = false;
|
||||
#else
|
||||
params.stencil = true;
|
||||
#endif
|
||||
params.imm_vbo_draw = NULL;
|
||||
params.imm_vbo_disable = NULL;
|
||||
#if defined(__APPLE__) && defined(HAVE_OPENGL)
|
||||
|
@ -1468,9 +1482,11 @@ static bool set_opengl_hw_render(u32 preferred)
|
|||
else
|
||||
#endif
|
||||
{
|
||||
#ifndef HAVE_OPENGLES
|
||||
params.context_type = (retro_hw_context_type)preferred;
|
||||
params.major = 3;
|
||||
params.minor = preferred == RETRO_HW_CONTEXT_OPENGL_CORE ? 2 : 0;
|
||||
#endif
|
||||
config::RendererType = RenderType::OpenGL;
|
||||
}
|
||||
|
||||
|
@ -1767,9 +1783,7 @@ bool retro_load_game_special(unsigned game_type, const struct retro_game_info *i
|
|||
void retro_unload_game()
|
||||
{
|
||||
INFO_LOG(COMMON, "Flycast unloading game");
|
||||
frontend_clear_thread_waits_cb(1, nullptr);
|
||||
emu.stop();
|
||||
frontend_clear_thread_waits_cb(0, nullptr);
|
||||
game_data.clear();
|
||||
disk_paths.clear();
|
||||
disk_labels.clear();
|
||||
|
@ -1832,6 +1846,7 @@ bool retro_unserialize(const void * data, size_t size)
|
|||
try {
|
||||
Deserializer deser(data, size);
|
||||
dc_loadstate(deser);
|
||||
retro_audio_flush_buffer();
|
||||
emu.start();
|
||||
|
||||
return true;
|
||||
|
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -44,7 +44,7 @@ public:
|
|||
void setRetroEnvironment(retro_environment_t retroEnv) {
|
||||
this->retroEnv = retroEnv;
|
||||
}
|
||||
void setOptionDefinitions(const retro_core_option_definition *optionDefs) {
|
||||
void setOptionDefinitions(const retro_core_option_v2_definition *optionDefs) {
|
||||
this->optionDefs = optionDefs;
|
||||
}
|
||||
|
||||
|
@ -57,7 +57,7 @@ private:
|
|||
std::vector<BaseOption *> options;
|
||||
std::string gameId;
|
||||
retro_environment_t retroEnv = nullptr;
|
||||
const retro_core_option_definition *optionDefs;
|
||||
const retro_core_option_v2_definition *optionDefs;
|
||||
|
||||
template<typename T, bool>
|
||||
friend class Option;
|
||||
|
@ -106,8 +106,8 @@ public:
|
|||
T& operator=(const T& v) { set(v); return value; }
|
||||
|
||||
protected:
|
||||
const retro_core_option_definition *findDefinition(const std::string& name) const {
|
||||
for (const retro_core_option_definition *pDef = settings.optionDefs; pDef->key != nullptr; pDef++)
|
||||
const retro_core_option_v2_definition *findDefinition(const std::string& name) const {
|
||||
for (const retro_core_option_v2_definition *pDef = settings.optionDefs; pDef->key != nullptr; pDef++)
|
||||
if (name == pDef->key)
|
||||
return pDef;
|
||||
return nullptr;
|
||||
|
@ -120,7 +120,7 @@ protected:
|
|||
retro_variable var { name.c_str() };
|
||||
if (settings.retroEnv(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value != nullptr)
|
||||
{
|
||||
const retro_core_option_definition *def = findDefinition(name);
|
||||
const retro_core_option_v2_definition *def = findDefinition(name);
|
||||
verify(def != nullptr);
|
||||
if (!strcmp(var.value, def->values[1].value)) // TODO change defs so that choice 1 is true (and choice 0 is false)
|
||||
return true;
|
||||
|
@ -138,7 +138,7 @@ protected:
|
|||
retro_variable var { name.c_str() };
|
||||
if (settings.retroEnv(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value != nullptr)
|
||||
{
|
||||
const retro_core_option_definition *def = findDefinition(name);
|
||||
const retro_core_option_v2_definition *def = findDefinition(name);
|
||||
verify(def != nullptr);
|
||||
for (int i = 0; def->values[i].value != nullptr; i++)
|
||||
if (!strcmp(var.value, def->values[i].value))
|
||||
|
|
Loading…
Reference in New Issue