Files
LonaRPG-Online-Games/Data/Scripts/000_Ruby310_Compat.rb
T

434 lines
11 KiB
Ruby
Raw Normal View History

2026-10-29 21:59:06 +04:00
# encoding: UTF-8
#==============================================================================
# Ruby 3.x / mkxp-z compatibility helpers for Data scripts.
# - UTF-8 safe text/json helpers
# - robust warning logging fallback
# - Win32API-compatible wrapper backed by Fiddle
#==============================================================================
module Ruby310Compat
@json_ready = false
@fiddle_ready = false
@fiddle_error = nil
@library_cache = {}
class << self
attr_reader :fiddle_error
end
def self.json_ready?
return true if @json_ready
begin
require 'json'
if defined?(JSON)
JSON.singleton_class.class_eval do
alias decode parse unless respond_to?(:decode)
alias encode generate unless respond_to?(:encode)
end
end
@json_ready = true
true
rescue LoadError, StandardError
@json_ready = false
false
end
end
def self.windows?
!!(RUBY_PLATFORM =~ /mswin|mingw|cygwin/i)
rescue
false
end
def self.fiddle_ready?
return true if @fiddle_ready
begin
require 'fiddle'
require 'fiddle/import'
@fiddle_ready = true
@fiddle_error = nil
true
rescue LoadError, StandardError => e
@fiddle_ready = false
@fiddle_error = e
false
end
end
def self.normalize_library_name(name)
name.to_s.strip.gsub('\\', '/')
end
def self.library_candidates(name)
raw = normalize_library_name(name)
return [] if raw == ''
candidates = []
candidates << raw
candidates << "#{raw}.dll" unless raw =~ /\.[A-Za-z0-9]+\z/
begin
base = Dir.pwd.to_s
unless base.nil? || base == ''
candidates << File.expand_path(raw, base)
candidates << File.expand_path("#{raw}.dll", base) unless raw =~ /\.[A-Za-z0-9]+\z/
end
rescue
end
uniq = {}
candidates.compact.map { |v| v.to_s }.reject { |v| v == '' }.select { |v| uniq[v] ? false : (uniq[v] = true) }
end
def self.open_library(name)
raise LoadError, 'Fiddle is unavailable' unless fiddle_ready?
cache_key = normalize_library_name(name)
handle = @library_cache[cache_key]
return handle if handle
last_error = nil
library_candidates(name).each do |candidate|
begin
handle = Fiddle.dlopen(candidate)
@library_cache[cache_key] = handle
return handle
rescue Fiddle::DLError, StandardError => e
last_error = e
end
end
raise(last_error || LoadError.new("Unable to load library: #{name}"))
end
def self.stdcall_abi
return @stdcall_abi if defined?(@stdcall_abi)
@stdcall_abi = begin
if defined?(Fiddle::Importer::CALL_TYPE_TO_ABI)
Fiddle::Importer::CALL_TYPE_TO_ABI[:stdcall] || Fiddle::Function::DEFAULT
else
Fiddle::Function::DEFAULT
end
rescue
Fiddle::Function::DEFAULT
end
end
def self.int_value(value)
return 1 if value == true
return 0 if value == false || value.nil?
value.to_i
rescue
0
end
def self.bootstrap_candidates
candidates = []
begin
cwd = Dir.pwd.to_s
unless cwd.nil? || cwd == ''
candidates << File.expand_path('Data/Scripts/000_Ruby310_Compat.rb', cwd)
candidates << File.expand_path('000_Ruby310_Compat.rb', cwd)
end
rescue StandardError
end
begin
script_dir = File.dirname(__FILE__)
unless script_dir.nil? || script_dir == ''
candidates << File.expand_path('000_Ruby310_Compat.rb', script_dir)
end
rescue StandardError
end
uniq = {}
candidates.compact.map { |entry| entry.to_s }.reject { |entry| entry.empty? }.select { |entry| uniq[entry] ? false : (uniq[entry] = true) }
end
def self.strip_utf8_bom(content)
return content if content.nil?
string = content.is_a?(String) ? content.dup : content.to_s
bytes = string.b
return string unless bytes.start_with?("\xEF\xBB\xBF")
stripped = bytes.byteslice(3, bytes.bytesize - 3) || ''.b
if string.encoding == Encoding::ASCII_8BIT
stripped
else
stripped.force_encoding(string.encoding)
end
rescue StandardError
content
end
def self.decode_text_content(content)
string = strip_utf8_bom(content)
return string unless string.respond_to?(:force_encoding)
return string unless string.encoding == Encoding::ASCII_8BIT
utf8 = string.dup
utf8.force_encoding(Encoding::UTF_8)
return utf8 if utf8.valid_encoding?
cp1251 = string.dup
cp1251.force_encoding(Encoding::Windows_1251)
return cp1251.encode(Encoding::UTF_8) if cp1251.valid_encoding?
string.force_encoding(Encoding::UTF_8)
rescue StandardError
content
end
def self.read_text_file(path)
decode_text_content(File.binread(path))
rescue StandardError
decode_text_content(File.read(path))
end
def self.normalize_json_source(content)
text = decode_text_content(content)
text = strip_utf8_bom(text)
return text unless text.respond_to?(:gsub)
text.gsub("\r\n", "\n").gsub("\r", "\n")
rescue StandardError
content
end
def self.decode_json_text(content)
json_ready?
JSON.decode(normalize_json_source(content))
end
def self.parse_json_file(path)
decode_json_text(read_text_file(path))
end
def self.ensure_bootstrapped
return true if defined?(Ruby310Compat)
bootstrap_candidates.each do |candidate|
next unless File.file?(candidate)
load candidate
return true if defined?(Ruby310Compat)
end
false
rescue StandardError
false
end
def self.ensure_user_data_dir
begin
Dir.mkdir('UserData') unless Dir.exist?('UserData')
rescue StandardError
end
end
def self.warning_log_path
ensure_user_data_dir
'UserData/ruby_warning_fallback.log'
end
def self.safe_warn_write(message)
text = begin
msg = message.nil? ? '' : message.to_s
msg.end_with?("\n") ? msg : (msg + "\n")
rescue StandardError
"warning: <unprintable>\n"
end
begin
File.open(warning_log_path, 'ab') { |f| f.write(text.b) }
true
rescue StandardError
false
end
end
end
Ruby310Compat.json_ready?
module Warning
class << self
unless method_defined?(:_ruby310compat_original_warn)
alias _ruby310compat_original_warn warn
end
def warn(message)
_ruby310compat_original_warn(message)
rescue StandardError
Ruby310Compat.safe_warn_write(message)
nil
end
end
end
module Kernel
unless method_defined?(:_ruby310compat_kernel_warn)
alias _ruby310compat_kernel_warn warn
end
def warn(*messages, **kwargs)
_ruby310compat_kernel_warn(*messages, **kwargs)
rescue StandardError
messages.each { |message| Ruby310Compat.safe_warn_write(message) }
nil
end
end
module Ruby310Compat
class NativeFunction
def initialize(dll_name, function_name, import = '', export = 'L')
@impl = if defined?(Win32API)
Win32API.new(dll_name, function_name, import, export)
else
raise LoadError, 'Win32API/Fiddle bridge is unavailable'
end
end
def call(*args)
@impl.call(*args)
end
alias Call call
end
def self.native_function(dll_name, function_name, import = '', export = 'L')
NativeFunction.new(dll_name, function_name, import, export)
end
class << self
alias native_api native_function
end
end
unless defined?(Win32API)
class Win32API
ARG_TYPE_MAP = {
'I' => proc { Fiddle::TYPE_INT },
'L' => proc { Fiddle::TYPE_LONG },
'P' => proc { Fiddle::TYPE_VOIDP },
'V' => proc { Fiddle::TYPE_VOID }
}
RET_TYPE_MAP = {
'I' => proc { Fiddle::TYPE_INT },
'L' => proc { Fiddle::TYPE_LONG },
'P' => proc { Fiddle::TYPE_VOIDP },
'V' => proc { Fiddle::TYPE_VOID }
}
def initialize(dll_name, function_name, import = '', export = 'L')
raise LoadError, 'Fiddle is unavailable' unless Ruby310Compat.fiddle_ready?
@dll_name = dll_name.to_s
@function_name = function_name.to_s
@import_signature = normalize_signature(import)
@export_signature = normalize_return_signature(export)
@handle = Ruby310Compat.open_library(@dll_name)
@function = Fiddle::Function.new(
@handle[@function_name],
@import_signature.map { |entry| map_arg_type(entry) },
map_return_type(@export_signature),
Ruby310Compat.stdcall_abi
)
end
def call(*args)
keepalive = []
converted = []
@import_signature.each_with_index do |sig, index|
converted << convert_arg(sig, args[index], keepalive)
end
result = @function.call(*converted)
convert_result(result)
end
alias Call call
private
def normalize_signature(signature)
case signature
when Array
signature.map { |entry| entry.to_s[0, 1].upcase }
else
signature.to_s.each_char.map { |entry| entry.to_s[0, 1].upcase }
end
rescue
[]
end
def normalize_return_signature(signature)
sig = signature.to_s
sig = 'V' if sig == ''
sig[0, 1].upcase
rescue
'V'
end
def map_arg_type(sig)
resolver = ARG_TYPE_MAP[sig]
raise ArgumentError, "Unsupported Win32API arg type: #{sig.inspect}" unless resolver
resolver.call
end
def map_return_type(sig)
resolver = RET_TYPE_MAP[sig]
raise ArgumentError, "Unsupported Win32API return type: #{sig.inspect}" unless resolver
resolver.call
end
def convert_arg(sig, value, keepalive)
case sig
when 'P'
convert_pointer_arg(value, keepalive)
when 'I', 'L'
Ruby310Compat.int_value(value)
when 'V'
nil
else
raise ArgumentError, "Unsupported Win32API arg type: #{sig.inspect}"
end
end
def convert_pointer_arg(value, keepalive)
return 0 if value.nil?
return value if defined?(Fiddle::Pointer) && value.is_a?(Fiddle::Pointer)
if value.is_a?(String)
keepalive << value
return Fiddle::Pointer[value]
end
if value.respond_to?(:to_str)
string_value = value.to_str
keepalive << string_value
return Fiddle::Pointer[string_value]
end
Ruby310Compat.int_value(value)
rescue
0
end
def convert_result(value)
case @export_signature
when 'V'
nil
when 'P'
ptr = Ruby310Compat.int_value(value)
return nil if ptr == 0
begin
Fiddle::Pointer.new(ptr).to_s
rescue
nil
end
else
Ruby310Compat.int_value(value)
end
end
end
end