mirror of
https://github.com/libretro/libretro-fceumm.git
synced 2024-12-28 20:04:22 +00:00
634 lines
27 KiB
Python
634 lines
27 KiB
Python
#!/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 ('""') and not 'NULL'.
|
||
|
||
:param text: String to be tested.
|
||
:return: bool
|
||
"""
|
||
return 2 < len(text) and text != 'NULL'
|
||
|
||
|
||
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_definition = 'retro_core_option_v2_definition' == struct_type_name[0]
|
||
pre_name = ''
|
||
# info texts format
|
||
p = cor.p_info
|
||
if 'retro_core_option_v2_category' == struct_type_name[0]:
|
||
# prepend category labels, as they can be the same as option labels
|
||
pre_name = 'CATEGORY_'
|
||
# categories have different info texts format
|
||
p = cor.p_info_cat
|
||
|
||
struct_content = struct.group(4)
|
||
# 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_definition:
|
||
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: key/value pairs
|
||
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):
|
||
# use the key if value not available
|
||
set_value = set_key
|
||
if not is_viable_value(set_value):
|
||
continue
|
||
# re.fullmatch(r'(?:[+-][0-9]+)+', value[1:-1])
|
||
|
||
# add only if non-dupe, not translated by RetroArch directly & not purely numeric
|
||
if set_value not in just_string[lang]\
|
||
and set_value.lower() not in ON_OFFS\
|
||
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
|
||
file_path = file_paths[file_lang]
|
||
try:
|
||
jsons[file_lang] = file_path[:file_path.rindex('.')] + '.json'
|
||
except ValueError:
|
||
print(f"File {file_path} has incorrect format! File ending missing?")
|
||
continue
|
||
|
||
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(intl_file_path: str, localisations_path: str, text: str, file_path: str) -> None:
|
||
"""Creates 'libretro_core_options_intl.h' from Crowdin translations.
|
||
|
||
:param intl_file_path: Path to 'libretro_core_options_intl.h'
|
||
:param localisations_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(intl_file_path):
|
||
# copy top of the file for re-use
|
||
with open(intl_file_path, 'r', encoding='utf-8') as intl: # libretro_core_options_intl.h
|
||
in_text = intl.read()
|
||
# attempt 1: find the distinct comment header
|
||
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:
|
||
# attempt 2: if no comment header present, find c++ compiler instruction (it is kind of a must)
|
||
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)]
|
||
# if all attempts fail, use default from above
|
||
|
||
# only write to file, if there is anything worthwhile to write!
|
||
overwrite = False
|
||
|
||
# iterate through localisation files
|
||
files = {}
|
||
for file in os.scandir(localisations_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()
|
||
# mark each language's section with a comment, for readability
|
||
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:
|
||
if '_us' != struct_type_name[2]:
|
||
# only use _us constructs - other languages present in the source file are not important
|
||
continue
|
||
new_decl = re.sub(re.escape(struct_type_name[2]), lang_low, declaration)
|
||
|
||
p = (cor.p_info_cat if 'retro_core_option_v2_category' == struct_type_name[0] else cor.p_info)
|
||
offset_construct = construct.start(0)
|
||
# append localised construct name and ' = {'
|
||
start = construct.end(1) - offset_construct
|
||
end = construct.start(4) - offset_construct
|
||
out_txt = out_txt + new_decl + construct.group(0)[start:end]
|
||
# insert macros
|
||
content = construct.group(4)
|
||
new_content = cor.p_option.sub(replace_option, content)
|
||
start = construct.end(4) - offset_construct
|
||
# append macro-filled content and close the 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(intl_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]) or sys.argv[1].endswith('.h'):
|
||
_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!')
|