246 lines
7.1 KiB
Ruby
246 lines
7.1 KiB
Ruby
unless defined?(Ruby310Compat)
|
|
begin
|
|
compat_candidates = []
|
|
begin
|
|
compat_candidates << File.expand_path('000_Ruby310_Compat.rb', File.dirname(__FILE__))
|
|
rescue StandardError
|
|
end
|
|
begin
|
|
cwd = Dir.pwd.to_s
|
|
compat_candidates << File.expand_path('Data/Scripts/000_Ruby310_Compat.rb', cwd) unless cwd.empty?
|
|
compat_candidates << File.expand_path('000_Ruby310_Compat.rb', cwd) unless cwd.empty?
|
|
rescue StandardError
|
|
end
|
|
compat_candidates.compact.uniq.each do |compat_path|
|
|
next unless File.file?(compat_path)
|
|
load compat_path
|
|
break if defined?(Ruby310Compat)
|
|
end
|
|
rescue StandardError
|
|
end
|
|
end
|
|
|
|
|
|
=begin
|
|
#===============================================================================
|
|
Title: Command-Line Args Loader
|
|
Author: Hime
|
|
Date: Mar 24, 2014
|
|
URL: http://www.himeworks.com/2014/03/24/command-line-args-loader/
|
|
--------------------------------------------------------------------------------
|
|
** Change log
|
|
Mar 24, 2014
|
|
- Initial release
|
|
--------------------------------------------------------------------------------
|
|
** Terms of Use
|
|
* Free to use in non-commercial projects
|
|
* Contact me for commercial use
|
|
* No real support. The script is provided as-is
|
|
* Will do bug fixes, but no compatibility patches
|
|
* Features may be requested but no guarantees, especially if it is non-trivial
|
|
* Credits to Hime Works in your project
|
|
* Preserve this header
|
|
--------------------------------------------------------------------------------
|
|
** Description
|
|
|
|
This script simply loads any command-line arguments into ARGV.
|
|
RM doesn't do this natively so we need to do it ourselves.
|
|
|
|
This script is meant to be used for games that will be using custom game
|
|
launchers that will supply command-line arguments.
|
|
|
|
--------------------------------------------------------------------------------
|
|
** Installation
|
|
|
|
In the script editor, place this above Modules
|
|
|
|
--------------------------------------------------------------------------------
|
|
** Usage
|
|
|
|
Access command-line arguments using ARGV
|
|
|
|
--------------------------------------------------------------------------------
|
|
** Credits
|
|
|
|
Zalerinian, for pointing out the GetCommandLine function
|
|
Authors of Shellwords module (included below)
|
|
|
|
#===============================================================================
|
|
=end
|
|
#===============================================================================
|
|
# ** Rest of script
|
|
#===============================================================================
|
|
|
|
#===============================================================================
|
|
# The Shellwords module is provided in the Ruby standard library and licensing
|
|
# details can be found here: https://www.ruby-lang.org/en/about/license.txt
|
|
#===============================================================================
|
|
#
|
|
# shellwords.rb: Manipulates strings a la UNIX Bourne shell
|
|
#
|
|
|
|
#
|
|
# This module manipulates strings according to the word parsing rules
|
|
# of the UNIX Bourne shell.
|
|
#
|
|
# The shellwords() function was originally a port of shellwords.pl,
|
|
# but modified to conform to POSIX / SUSv3 (IEEE Std 1003.1-2001).
|
|
#
|
|
# Authors:
|
|
# - Wakou Aoyama
|
|
# - Akinori MUSHA <knu@iDaemons.org>
|
|
#
|
|
# Contact:
|
|
# - Akinori MUSHA <knu@iDaemons.org> (current maintainer)
|
|
#
|
|
module Shellwords
|
|
# Splits a string into an array of tokens in the same way the UNIX
|
|
# Bourne shell does.
|
|
#
|
|
# argv = Shellwords.split('here are "two words"')
|
|
# argv #=> ["here", "are", "two words"]
|
|
#
|
|
# String#shellsplit is a shorthand for this function.
|
|
#
|
|
# argv = 'here are "two words"'.shellsplit
|
|
# argv #=> ["here", "are", "two words"]
|
|
def shellsplit(line)
|
|
words = []
|
|
field = ''
|
|
line.scan(/\G\s*(?>([^\s\\\'\"]+)|'([^\']*)'|"((?:[^\"\\]|\\.)*)"|(\\.?)|(\S))(\s|\z)?/m) do
|
|
|word, sq, dq, esc, garbage, sep|
|
|
raise ArgumentError, "Unmatched double quote: #{line.inspect}" if garbage
|
|
field << (word || sq || (dq || esc).gsub(/\\(.)/, '\\1'))
|
|
if sep
|
|
words << field
|
|
field = ''
|
|
end
|
|
end
|
|
words
|
|
end
|
|
|
|
alias shellwords shellsplit
|
|
|
|
module_function :shellsplit, :shellwords
|
|
|
|
class << self
|
|
alias split shellsplit
|
|
end
|
|
|
|
# Escapes a string so that it can be safely used in a Bourne shell
|
|
# command line.
|
|
#
|
|
# Note that a resulted string should be used unquoted and is not
|
|
# intended for use in double quotes nor in single quotes.
|
|
#
|
|
# open("| grep #{Shellwords.escape(pattern)} file") { |pipe|
|
|
# # ...
|
|
# }
|
|
#
|
|
# String#shellescape is a shorthand for this function.
|
|
#
|
|
# open("| grep #{pattern.shellescape} file") { |pipe|
|
|
# # ...
|
|
# }
|
|
#
|
|
# It is caller's responsibility to encode the string in the right
|
|
# encoding for the shell environment where this string is used.
|
|
# Multibyte characters are treated as multibyte characters, not
|
|
# bytes.
|
|
def shellescape(str)
|
|
# An empty argument will be skipped, so return empty quotes.
|
|
return "''" if str.empty?
|
|
|
|
str = str.dup
|
|
|
|
# Treat multibyte characters as is. It is caller's responsibility
|
|
# to encode the string in the right encoding for the shell
|
|
# environment.
|
|
str.gsub!(/([^A-Za-z0-9_\-.,:\/@\n])/, "\\\\\\1")
|
|
|
|
# A LF cannot be escaped with a backslash because a backslash + LF
|
|
# combo is regarded as line continuation and simply ignored.
|
|
str.gsub!(/\n/, "'\n'")
|
|
|
|
return str
|
|
end
|
|
|
|
module_function :shellescape
|
|
|
|
class << self
|
|
alias escape shellescape
|
|
end
|
|
|
|
# Builds a command line string from an argument list +array+ joining
|
|
# all elements escaped for Bourne shell and separated by a space.
|
|
#
|
|
# open('|' + Shellwords.join(['grep', pattern, *files])) { |pipe|
|
|
# # ...
|
|
# }
|
|
#
|
|
# Array#shelljoin is a shorthand for this function.
|
|
#
|
|
# open('|' + ['grep', pattern, *files].shelljoin) { |pipe|
|
|
# # ...
|
|
# }
|
|
#
|
|
def shelljoin(array)
|
|
array.map { |arg| shellescape(arg) }.join(' ')
|
|
end
|
|
|
|
module_function :shelljoin
|
|
|
|
class << self
|
|
alias join shelljoin
|
|
end
|
|
end
|
|
|
|
class String
|
|
# call-seq:
|
|
# str.shellsplit => array
|
|
#
|
|
# Splits +str+ into an array of tokens in the same way the UNIX
|
|
# Bourne shell does. See Shellwords::shellsplit for details.
|
|
def shellsplit
|
|
Shellwords.split(self)
|
|
end
|
|
|
|
# call-seq:
|
|
# str.shellescape => string
|
|
#
|
|
# Escapes +str+ so that it can be safely used in a Bourne shell
|
|
# command line. See Shellwords::shellescape for details.
|
|
def shellescape
|
|
Shellwords.escape(self)
|
|
end
|
|
end
|
|
|
|
class Array
|
|
# call-seq:
|
|
# array.shelljoin => string
|
|
#
|
|
# Builds a command line string from an argument list +array+ joining
|
|
# all elements escaped for Bourne shell and separated by a space.
|
|
# See Shellwords::shelljoin for details.
|
|
def shelljoin
|
|
Shellwords.join(self)
|
|
end
|
|
end
|
|
|
|
#===============================================================================
|
|
# My code
|
|
#===============================================================================
|
|
if defined?(Ruby310Compat)
|
|
fnGetCommandLine = Ruby310Compat.native_api("Kernel32", "GetCommandLine", "", "P")
|
|
parsed_argv = Shellwords.shellwords(fnGetCommandLine.call)
|
|
parsed_argv.shift
|
|
else
|
|
parsed_argv = []
|
|
end
|
|
|
|
if defined?(ARGV) && ARGV.respond_to?(:replace)
|
|
ARGV.replace(parsed_argv)
|
|
else
|
|
Object.const_set(:ARGV, parsed_argv)
|
|
end
|