diff options
Diffstat (limited to 'ruby.c')
| -rw-r--r-- | ruby.c | 2047 |
1 files changed, 1480 insertions, 567 deletions
@@ -11,77 +11,170 @@ **********************************************************************/ -#ifdef __CYGWIN__ -#include <windows.h> -#include <sys/cygwin.h> -#endif -#include "ruby/ruby.h" -#include "ruby/encoding.h" -#include "internal.h" -#include "eval_intern.h" -#include "dln.h" +#include "ruby/internal/config.h" + +#include <ctype.h> #include <stdio.h> #include <sys/types.h> -#include <ctype.h> + +#ifdef __CYGWIN__ +# include <windows.h> +# include <sys/cygwin.h> +#endif #ifdef __hpux -#include <sys/pstat.h> +# include <sys/pstat.h> #endif -#if defined(LOAD_RELATIVE) && defined(HAVE_DLADDR) -#include <dlfcn.h> + +#if (defined(LOAD_RELATIVE) || defined(__MACH__)) && defined(HAVE_DLADDR) +# include <dlfcn.h> #endif #ifdef HAVE_UNISTD_H -#include <unistd.h> +# include <unistd.h> #endif + #if defined(HAVE_FCNTL_H) -#include <fcntl.h> +# include <fcntl.h> #elif defined(HAVE_SYS_FCNTL_H) -#include <sys/fcntl.h> +# include <sys/fcntl.h> #endif + #ifdef HAVE_SYS_PARAM_H # include <sys/param.h> #endif + +#include "dln.h" +#include "eval_intern.h" +#include "internal.h" +#include "internal/error.h" +#include "internal/file.h" +#include "internal/inits.h" +#include "internal/io.h" +#include "internal/load.h" +#include "internal/loadpath.h" +#include "internal/missing.h" +#include "internal/object.h" +#include "internal/parse.h" +#include "internal/process.h" +#include "internal/variable.h" +#include "mjit.h" +#include "yjit.h" +#include "ruby/encoding.h" +#include "ruby/thread.h" +#include "ruby/util.h" +#include "ruby/version.h" +#include "ruby/internal/error.h" + #ifndef MAXPATHLEN # define MAXPATHLEN 1024 #endif +#ifndef O_ACCMODE +# define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR) +#endif -#include "ruby/util.h" +void Init_ruby_description(void); #ifndef HAVE_STDLIB_H char *getenv(); #endif -#define DISABLE_BIT(bit) (1U << disable_##bit) -enum disable_flag_bits { - disable_gems, - disable_rubyopt, - disable_flag_count +#ifndef DISABLE_RUBYGEMS +# define DISABLE_RUBYGEMS 0 +#endif +#if DISABLE_RUBYGEMS +#define DEFAULT_RUBYGEMS_ENABLED "disabled" +#else +#define DEFAULT_RUBYGEMS_ENABLED "enabled" +#endif + +void rb_warning_category_update(unsigned int mask, unsigned int bits); + +#define COMMA , +#define FEATURE_BIT(bit) (1U << feature_##bit) +#define EACH_FEATURES(X, SEP) \ + X(gems) \ + SEP \ + X(error_highlight) \ + SEP \ + X(did_you_mean) \ + SEP \ + X(rubyopt) \ + SEP \ + X(frozen_string_literal) \ + SEP \ + X(mjit) \ + SEP \ + X(yjit) + /* END OF FEATURES */ +#define EACH_DEBUG_FEATURES(X, SEP) \ + X(frozen_string_literal) \ + /* END OF DEBUG FEATURES */ +#define AMBIGUOUS_FEATURE_NAMES 0 /* no ambiguous feature names now */ +#define DEFINE_FEATURE(bit) feature_##bit +#define DEFINE_DEBUG_FEATURE(bit) feature_debug_##bit +enum feature_flag_bits { + EACH_FEATURES(DEFINE_FEATURE, COMMA), + feature_debug_flag_first, + feature_debug_flag_begin = feature_debug_flag_first - 1, + EACH_DEBUG_FEATURES(DEFINE_DEBUG_FEATURE, COMMA), + feature_flag_count }; +#define DEBUG_BIT(bit) (1U << feature_debug_##bit) + #define DUMP_BIT(bit) (1U << dump_##bit) +#define DEFINE_DUMP(bit) dump_##bit +#define EACH_DUMPS(X, SEP) \ + X(version) \ + SEP \ + X(copyright) \ + SEP \ + X(usage) \ + SEP \ + X(help) \ + SEP \ + X(yydebug) \ + SEP \ + X(syntax) \ + SEP \ + X(parsetree) \ + SEP \ + X(parsetree_with_comment) \ + SEP \ + X(insns) \ + SEP \ + X(insns_without_opt) \ + /* END OF DUMPS */ enum dump_flag_bits { - dump_version, - dump_copyright, - dump_usage, - dump_yydebug, - dump_syntax, - dump_parsetree, - dump_parsetree_with_comment, - dump_insns, - dump_flag_count + dump_version_v, + EACH_DUMPS(DEFINE_DUMP, COMMA), + dump_exit_bits = (DUMP_BIT(yydebug) | DUMP_BIT(syntax) | + DUMP_BIT(parsetree) | DUMP_BIT(parsetree_with_comment) | + DUMP_BIT(insns) | DUMP_BIT(insns_without_opt)) }; -struct cmdline_options { - int sflag, xflag; - int do_loop, do_print; - int do_line, do_split; - int do_search; - unsigned int disable; - int verbose; - int safe_level; - unsigned int setids; - unsigned int dump; +typedef struct ruby_cmdline_options ruby_cmdline_options_t; + +typedef struct { + unsigned int mask; + unsigned int set; +} ruby_features_t; + +static inline void +rb_feature_set_to(ruby_features_t *feat, unsigned int bit_mask, unsigned int bit_set) +{ + feat->mask |= bit_mask; + feat->set = (feat->set & ~bit_mask) | bit_set; +} + +#define FEATURE_SET_TO(feat, bit_mask, bit_set) \ + rb_feature_set_to(&(feat), bit_mask, bit_set) +#define FEATURE_SET(feat, bits) FEATURE_SET_TO(feat, bits, bits) +#define FEATURE_SET_RESTORE(feat, save) FEATURE_SET_TO(feat, (save).mask, (save).set & (save).mask) +#define FEATURE_SET_P(feat, bits) ((feat).set & (bits)) + +struct ruby_cmdline_options { const char *script; VALUE script_name; VALUE e_script; @@ -92,28 +185,72 @@ struct cmdline_options { } enc; } src, ext, intern; VALUE req_list; + ruby_features_t features; + ruby_features_t warn; + unsigned int dump; +#if USE_MJIT + struct mjit_options mjit; +#endif + struct rb_yjit_options yjit; + + int sflag, xflag; + unsigned int warning: 1; + unsigned int verbose: 1; + unsigned int do_loop: 1; + unsigned int do_print: 1; + unsigned int do_line: 1; + unsigned int do_split: 1; + unsigned int do_search: 1; + unsigned int setids: 2; }; -static void init_ids(struct cmdline_options *); +static void init_ids(ruby_cmdline_options_t *); #define src_encoding_index GET_VM()->src_encoding_index -static struct cmdline_options * -cmdline_options_init(struct cmdline_options *opt) +enum { + COMPILATION_FEATURES = ( + 0 + | FEATURE_BIT(frozen_string_literal) + | FEATURE_BIT(debug_frozen_string_literal) + ), + DEFAULT_FEATURES = ( + (FEATURE_BIT(debug_flag_first)-1) +#if DISABLE_RUBYGEMS + & ~FEATURE_BIT(gems) +#endif + & ~FEATURE_BIT(frozen_string_literal) + & ~FEATURE_BIT(mjit) + & ~FEATURE_BIT(yjit) + ) +}; + +static ruby_cmdline_options_t * +cmdline_options_init(ruby_cmdline_options_t *opt) { MEMZERO(opt, *opt, 1); init_ids(opt); opt->src.enc.index = src_encoding_index; opt->ext.enc.index = -1; opt->intern.enc.index = -1; -#if defined DISABLE_RUBYGEMS && DISABLE_RUBYGEMS - opt->disable |= DISABLE_BIT(gems); + opt->features.set = DEFAULT_FEATURES; +#ifdef MJIT_FORCE_ENABLE /* to use with: ./configure cppflags="-DMJIT_FORCE_ENABLE" */ + opt->features.set |= FEATURE_BIT(mjit); +#elif defined(YJIT_FORCE_ENABLE) + opt->features.set |= FEATURE_BIT(yjit); #endif + + if (getenv("RUBY_YJIT_ENABLE")) { + opt->features.set |= FEATURE_BIT(yjit); + } + return opt; } -static NODE *load_file(VALUE, const char *, int, struct cmdline_options *); -static void forbid_setid(const char *, struct cmdline_options *); +static rb_ast_t *load_file(VALUE parser, VALUE fname, VALUE f, int script, + ruby_cmdline_options_t *opt); +static VALUE open_load_file(VALUE fname_v, int *xflag); +static void forbid_setid(const char *, const ruby_cmdline_options_t *); #define forbid_setid(s) forbid_setid((s), opt) static struct { @@ -121,88 +258,156 @@ static struct { char **argv; } origarg; +static const char esc_standout[] = "\n\033[1;7m"; +static const char esc_bold[] = "\033[1m"; +static const char esc_reset[] = "\033[0m"; +static const char esc_none[] = ""; + +static void +show_usage_line(const char *str, unsigned int namelen, unsigned int secondlen, int help, int highlight, unsigned int w) +{ + const char *sb = highlight ? esc_bold : esc_none; + const char *se = highlight ? esc_reset : esc_none; + const int wrap = help && namelen + secondlen - 1 > w; + printf(" %s%.*s%-*.*s%s%-*s%s\n", sb, namelen-1, str, + (wrap ? 0 : w - namelen + 1), + (help ? secondlen-1 : 0), str + namelen, se, + (wrap ? w + 3 : 0), (wrap ? "\n" : ""), + str + namelen + secondlen); +} + static void -usage(const char *name) +usage(const char *name, int help, int highlight, int columns) { /* This message really ought to be max 23 lines. * Removed -h because the user already knows that option. Others? */ - static const char *const usage_msg[] = { - "-0[octal] specify record separator (\\0, if no argument)", - "-a autosplit mode with -n or -p (splits $_ into $F)", - "-c check syntax only", - "-Cdirectory cd to directory, before executing your script", - "-d set debugging flags (set $DEBUG to true)", - "-e 'command' one line of script. Several -e's allowed. Omit [programfile]", - "-Eex[:in] specify the default external and internal character encodings", - "-Fpattern split() pattern for autosplit (-a)", - "-i[extension] edit ARGV files in place (make backup if extension supplied)", - "-Idirectory specify $LOAD_PATH directory (may be used more than once)", - "-l enable line ending processing", - "-n assume 'while gets(); ... end' loop around your script", - "-p assume loop like -n but print line also like sed", - "-rlibrary require the library, before executing your script", - "-s enable some switch parsing for switches after script name", - "-S look for the script using PATH environment variable", - "-T[level=1] turn on tainting checks", - "-v print version number, then turn on verbose mode", - "-w turn warnings on for your script", - "-W[level=2] set warning level; 0=silence, 1=medium, 2=verbose", - "-x[directory] strip off text before #!ruby line and perhaps cd to directory", - "--copyright print the copyright", - "--version print the version", - NULL + struct message { + const char *str; + unsigned short namelen, secondlen; }; - const char *const *p = usage_msg; - - printf("Usage: %s [switches] [--] [programfile] [arguments]\n", name); - while (*p) - printf(" %s\n", *p++); -} - -#ifdef MANGLED_PATH -static VALUE -rubylib_mangled_path(const char *s, unsigned int l) -{ - static char *newp, *oldp; - static int newl, oldl, notfound; - char *ptr; - VALUE ret; - - if (!newp && !notfound) { - newp = getenv("RUBYLIB_PREFIX"); - if (newp) { - oldp = newp = strdup(newp); - while (*newp && !ISSPACE(*newp) && *newp != ';') { - newp = CharNext(newp); /* Skip digits. */ - } - oldl = newp - oldp; - while (*newp && (ISSPACE(*newp) || *newp == ';')) { - newp = CharNext(newp); /* Skip whitespace. */ - } - newl = strlen(newp); - if (newl == 0 || oldl == 0) { - rb_fatal("malformed RUBYLIB_PREFIX"); - } - translit_char(newp, '\\', '/'); - } - else { - notfound = 1; - } - } - if (!newp || l < oldl || STRNCASECMP(oldp, s, oldl) != 0) { - return rb_str_new(s, l); - } - ret = rb_str_new(0, l + newl - oldl); - ptr = RSTRING_PTR(ret); - memcpy(ptr, newp, newl); - memcpy(ptr + newl, s + oldl, l - oldl); - ptr[l + newl - oldl] = 0; - return ret; +#define M(shortopt, longopt, desc) { \ + shortopt " " longopt " " desc, \ + (unsigned short)sizeof(shortopt), \ + (unsigned short)sizeof(longopt), \ } +#if YJIT_SUPPORTED_P +# define PLATFORM_JIT_OPTION "--yjit" #else -#define rubylib_mangled_path rb_str_new +# define PLATFORM_JIT_OPTION "--mjit" +#endif + static const struct message usage_msg[] = { + M("-0[octal]", "", "specify record separator (\\0, if no argument)"), + M("-a", "", "autosplit mode with -n or -p (splits $_ into $F)"), + M("-c", "", "check syntax only"), + M("-Cdirectory", "", "cd to directory before executing your script"), + M("-d", ", --debug", "set debugging flags (set $DEBUG to true)"), + M("-e 'command'", "", "one line of script. Several -e's allowed. Omit [programfile]"), + M("-Eex[:in]", ", --encoding=ex[:in]", "specify the default external and internal character encodings"), + M("-Fpattern", "", "split() pattern for autosplit (-a)"), + M("-i[extension]", "", "edit ARGV files in place (make backup if extension supplied)"), + M("-Idirectory", "", "specify $LOAD_PATH directory (may be used more than once)"), + M("-l", "", "enable line ending processing"), + M("-n", "", "assume 'while gets(); ... end' loop around your script"), + M("-p", "", "assume loop like -n but print line also like sed"), + M("-rlibrary", "", "require the library before executing your script"), + M("-s", "", "enable some switch parsing for switches after script name"), + M("-S", "", "look for the script using PATH environment variable"), + M("-v", "", "print the version number, then turn on verbose mode"), + M("-w", "", "turn warnings on for your script"), + M("-W[level=2|:category]", "", "set warning level; 0=silence, 1=medium, 2=verbose"), + M("-x[directory]", "", "strip off text before #!ruby line and perhaps cd to directory"), + M("--jit", "", "enable JIT for the platform, same as " PLATFORM_JIT_OPTION " (experimental)"), + M("--mjit", "", "enable C compiler-based JIT compiler (experimental)"), + M("--yjit", "", "enable in-process JIT compiler (experimental)"), + M("-h", "", "show this message, --help for more info"), + }; + static const struct message help_msg[] = { + M("--copyright", "", "print the copyright"), + M("--dump={insns|parsetree|...}[,...]", "", + "dump debug information. see below for available dump list"), + M("--enable={mjit|rubyopt|...}[,...]", ", --disable={mjit|rubyopt|...}[,...]", + "enable or disable features. see below for available features"), + M("--external-encoding=encoding", ", --internal-encoding=encoding", + "specify the default external or internal character encoding"), + M("--backtrace-limit=num", "", "limit the maximum length of backtrace"), + M("--verbose", "", "turn on verbose mode and disable script from stdin"), + M("--version", "", "print the version number, then exit"), + M("--help", "", "show this message, -h for short message"), + }; + static const struct message dumps[] = { + M("insns", "", "instruction sequences"), + M("insns_without_opt", "", "instruction sequences compiled with no optimization"), + M("yydebug", "", "yydebug of yacc parser generator"), + M("parsetree", "", "AST"), + M("parsetree_with_comment", "", "AST with comments"), + }; + static const struct message features[] = { + M("gems", "", "rubygems (only for debugging, default: "DEFAULT_RUBYGEMS_ENABLED")"), + M("error_highlight", "", "error_highlight (default: "DEFAULT_RUBYGEMS_ENABLED")"), + M("did_you_mean", "", "did_you_mean (default: "DEFAULT_RUBYGEMS_ENABLED")"), + M("rubyopt", "", "RUBYOPT environment variable (default: enabled)"), + M("frozen-string-literal", "", "freeze all string literals (default: disabled)"), + M("mjit", "", "C compiler-based JIT compiler (default: disabled)"), + M("yjit", "", "in-process JIT compiler (default: disabled)"), + }; + static const struct message warn_categories[] = { + M("deprecated", "", "deprecated features"), + M("experimental", "", "experimental features"), + }; + static const struct message mjit_options[] = { + M("--mjit-warnings", "", "Enable printing JIT warnings"), + M("--mjit-debug", "", "Enable JIT debugging (very slow), or add cflags if specified"), + M("--mjit-wait", "", "Wait until JIT compilation finishes every time (for testing)"), + M("--mjit-save-temps", "", "Save JIT temporary files in $TMP or /tmp (for testing)"), + M("--mjit-verbose=num", "", "Print JIT logs of level num or less to stderr (default: 0)"), + M("--mjit-max-cache=num", "", "Max number of methods to be JIT-ed in a cache (default: 10000)"), + M("--mjit-min-calls=num", "", "Number of calls to trigger JIT (for testing, default: 10000)"), + }; + static const struct message yjit_options[] = { +#if YJIT_STATS + M("--yjit-stats", "", "Enable collecting YJIT statistics"), #endif + M("--yjit-exec-mem-size=num", "", "Size of executable memory block in MiB (default: 256)"), + M("--yjit-call-threshold", "", "Number of calls to trigger JIT (default: 10)"), + M("--yjit-max-versions", "", "Maximum number of versions per basic block (default: 4)"), + M("--yjit-greedy-versioning", "", "Greedy versioning mode (default: disabled)"), + }; + int i; + const char *sb = highlight ? esc_standout+1 : esc_none; + const char *se = highlight ? esc_reset : esc_none; + const int num = numberof(usage_msg) - (help ? 1 : 0); + unsigned int w = (columns > 80 ? (columns - 79) / 2 : 0) + 16; +#define SHOW(m) show_usage_line((m).str, (m).namelen, (m).secondlen, help, highlight, w) + + printf("%sUsage:%s %s [switches] [--] [programfile] [arguments]\n", sb, se, name); + for (i = 0; i < num; ++i) + SHOW(usage_msg[i]); + + if (!help) return; + + if (highlight) sb = esc_standout; + + for (i = 0; i < numberof(help_msg); ++i) + SHOW(help_msg[i]); + printf("%s""Dump List:%s\n", sb, se); + for (i = 0; i < numberof(dumps); ++i) + SHOW(dumps[i]); + printf("%s""Features:%s\n", sb, se); + for (i = 0; i < numberof(features); ++i) + SHOW(features[i]); + printf("%s""Warning categories:%s\n", sb, se); + for (i = 0; i < numberof(warn_categories); ++i) + SHOW(warn_categories[i]); + printf("%s""MJIT options (experimental):%s\n", sb, se); + for (i = 0; i < numberof(mjit_options); ++i) + SHOW(mjit_options[i]); + printf("%s""YJIT options (experimental):%s\n", sb, se); + for (i = 0; i < numberof(yjit_options); ++i) + SHOW(yjit_options[i]); +} + +#define rubylib_path_new rb_str_new static void push_include(const char *path, VALUE (*filter)(VALUE)) @@ -217,7 +422,7 @@ push_include(const char *path, VALUE (*filter)(VALUE)) p++; if (!*p) break; for (s = p; *s && *s != sep; s = CharNext(s)); - rb_ary_push(load_path, (*filter)(rubylib_mangled_path(p, s - p))); + rb_ary_push(load_path, (*filter)(rubylib_path_new(p, s - p))); p = s; } } @@ -252,8 +457,7 @@ push_include_cygwin(const char *path, VALUE (*filter)(VALUE)) #define CONV_TO_POSIX_PATH(p, lib) \ cygwin_conv_path(CCP_WIN_A_TO_POSIX|CCP_RELATIVE, (p), (lib), sizeof(lib)) #else -#define CONV_TO_POSIX_PATH(p, lib) \ - cygwin_conv_to_posix_path((p), (lib)) +# error no cygwin_conv_path #endif if (CONV_TO_POSIX_PATH(p, rubylib) == 0) p = rubylib; @@ -309,6 +513,7 @@ ruby_incpush_expand(const char *path) ruby_push_include(path, expand_include_path); } +#undef UTF8_PATH #if defined _WIN32 || defined __CYGWIN__ static HMODULE libruby; @@ -325,141 +530,229 @@ rb_libruby_handle(void) { return libruby; } + +static inline void +translit_char_bin(char *p, int from, int to) +{ + while (*p) { + if ((unsigned char)*p == from) + *p = to; + p++; + } +} #endif -void ruby_init_loadpath_safe(int safe_level); +#ifdef _WIN32 +# define UTF8_PATH 1 +#endif -void -ruby_init_loadpath(void) +#ifndef UTF8_PATH +# define UTF8_PATH 0 +#endif +#if UTF8_PATH +# define IF_UTF8_PATH(t, f) t +#else +# define IF_UTF8_PATH(t, f) f +#endif + +#if UTF8_PATH +static VALUE +str_conv_enc(VALUE str, rb_encoding *from, rb_encoding *to) { - ruby_init_loadpath_safe(0); + return rb_str_conv_enc_opts(str, from, to, + ECONV_UNDEF_REPLACE|ECONV_INVALID_REPLACE, + Qnil); } +#else +# define str_conv_enc(str, from, to) (str) +#endif -void -ruby_init_loadpath_safe(int safe_level) +void ruby_init_loadpath(void); + +#if defined(LOAD_RELATIVE) || defined(__MACH__) +static VALUE +runtime_libruby_path(void) { - VALUE load_path; - ID id_initial_load_path_mark; - extern const char ruby_initial_load_paths[]; - const char *paths = ruby_initial_load_paths; -#if defined LOAD_RELATIVE -# if defined HAVE_DLADDR || defined HAVE_CYGWIN_CONV_PATH -# define VARIABLE_LIBPATH 1 -# else -# define VARIABLE_LIBPATH 0 -# endif -# if VARIABLE_LIBPATH +#if defined _WIN32 || defined __CYGWIN__ + DWORD len, ret; +#if USE_RVARGC + len = 32; +#else + len = RSTRING_EMBED_LEN_MAX; +#endif + VALUE path; + VALUE wsopath = rb_str_new(0, len*sizeof(WCHAR)); + WCHAR *wlibpath; char *libpath; - VALUE sopath; -# else - char libpath[MAXPATHLEN + 1]; -# endif - size_t baselen; - char *p; -#if defined _WIN32 || defined __CYGWIN__ -# if VARIABLE_LIBPATH - sopath = rb_str_new(0, MAXPATHLEN); - libpath = RSTRING_PTR(sopath); - GetModuleFileName(libruby, libpath, MAXPATHLEN); -# else - GetModuleFileName(libruby, libpath, sizeof libpath); -# endif -#elif defined(__EMX__) - _execname(libpath, sizeof(libpath) - 1); + while (wlibpath = (WCHAR *)RSTRING_PTR(wsopath), + ret = GetModuleFileNameW(libruby, wlibpath, len), + (ret == len)) + { + rb_str_modify_expand(wsopath, len*sizeof(WCHAR)); + rb_str_set_len(wsopath, (len += len)*sizeof(WCHAR)); + } + if (!ret || ret > len) rb_fatal("failed to get module file name"); +#if defined __CYGWIN__ + { + const int win_to_posix = CCP_WIN_W_TO_POSIX | CCP_RELATIVE; + size_t newsize = cygwin_conv_path(win_to_posix, wlibpath, 0, 0); + if (!newsize) rb_fatal("failed to convert module path to cygwin"); + path = rb_str_new(0, newsize); + libpath = RSTRING_PTR(path); + if (cygwin_conv_path(win_to_posix, wlibpath, libpath, newsize)) { + rb_str_resize(path, 0); + } + } +#else + { + DWORD i; + for (len = ret, i = 0; i < len; ++i) { + if (wlibpath[i] == L'\\') { + wlibpath[i] = L'/'; + ret = i+1; /* chop after the last separator */ + } + } + } + len = WideCharToMultiByte(CP_UTF8, 0, wlibpath, ret, NULL, 0, NULL, NULL); + path = rb_utf8_str_new(0, len); + libpath = RSTRING_PTR(path); + WideCharToMultiByte(CP_UTF8, 0, wlibpath, ret, libpath, len, NULL, NULL); +#endif + rb_str_resize(wsopath, 0); + return path; #elif defined(HAVE_DLADDR) Dl_info dli; - if (dladdr((void *)(VALUE)expand_include_path, &dli)) { - char fbuf[MAXPATHLEN]; - char *f = dln_find_file_r(dli.dli_fname, getenv(PATH_ENV), fbuf, sizeof(fbuf)); - VALUE fname = rb_str_new_cstr(f ? f : dli.dli_fname); - rb_str_freeze(fname); - sopath = rb_realpath_internal(Qnil, fname, 1); + VALUE fname, path; + const void* addr = (void *)(VALUE)expand_include_path; + + if (!dladdr((void *)addr, &dli)) { + return rb_str_new(0, 0); } +#ifdef __linux__ + else if (origarg.argc > 0 && origarg.argv && dli.dli_fname == origarg.argv[0]) { + fname = rb_str_new_cstr("/proc/self/exe"); + path = rb_readlink(fname, NULL); + } +#endif else { - sopath = rb_str_new(0, 0); + fname = rb_str_new_cstr(dli.dli_fname); + path = rb_realpath_internal(Qnil, fname, 1); } - libpath = RSTRING_PTR(sopath); + rb_str_resize(fname, 0); + return path; +#else +# error relative load path is not supported on this platform. +#endif +} #endif -#if !VARIABLE_LIBPATH - libpath[sizeof(libpath) - 1] = '\0'; +#define INITIAL_LOAD_PATH_MARK rb_intern_const("@gem_prelude_index") + +VALUE ruby_archlibdir_path, ruby_prefix_path; +#if defined(__MACH__) +// A path to libruby.dylib itself or where it's statically linked to. +VALUE rb_libruby_selfpath; #endif -#if defined DOSISH - translit_char(libpath, '\\', '/'); -#elif defined __CYGWIN__ - { -# if VARIABLE_LIBPATH - const int win_to_posix = CCP_WIN_A_TO_POSIX | CCP_RELATIVE; - size_t newsize = cygwin_conv_path(win_to_posix, libpath, 0, 0); - if (newsize > 0) { - VALUE rubylib = rb_str_new(0, newsize); - p = RSTRING_PTR(rubylib); - if (cygwin_conv_path(win_to_posix, libpath, p, newsize) == 0) { - rb_str_resize(sopath, 0); - sopath = rubylib; - libpath = p; - } - } -# else - char rubylib[FILENAME_MAX]; - cygwin_conv_to_posix_path(libpath, rubylib); - strncpy(libpath, rubylib, sizeof(libpath)); + +void +ruby_init_loadpath(void) +{ + VALUE load_path, archlibdir = 0; + ID id_initial_load_path_mark; + const char *paths = ruby_initial_load_paths; +#if defined(LOAD_RELATIVE) || defined(__MACH__) + VALUE libruby_path = runtime_libruby_path(); +# if defined(__MACH__) + rb_libruby_selfpath = libruby_path; + rb_gc_register_address(&rb_libruby_selfpath); # endif - } #endif + +#if defined LOAD_RELATIVE +#if !defined ENABLE_MULTIARCH +# define RUBY_ARCH_PATH "" +#elif defined RUBY_ARCH +# define RUBY_ARCH_PATH "/"RUBY_ARCH +#else +# define RUBY_ARCH_PATH "/"RUBY_PLATFORM +#endif + char *libpath; + VALUE sopath; + size_t baselen; + const char *p; + + sopath = libruby_path; + libpath = RSTRING_PTR(sopath); + p = strrchr(libpath, '/'); if (p) { - static const char bindir[] = "/bin"; + static const char libdir[] = "/" #ifdef LIBDIR_BASENAME - static const char libdir[] = "/"LIBDIR_BASENAME; + LIBDIR_BASENAME #else - static const char libdir[] = "/lib"; + "lib" #endif + RUBY_ARCH_PATH; + const ptrdiff_t libdir_len = (ptrdiff_t)sizeof(libdir) + - rb_strlen_lit(RUBY_ARCH_PATH) - 1; + static const char bindir[] = "/bin"; const ptrdiff_t bindir_len = (ptrdiff_t)sizeof(bindir) - 1; - const ptrdiff_t libdir_len = (ptrdiff_t)sizeof(libdir) - 1; - *p = 0; - if (p - libpath >= bindir_len && !STRCASECMP(p - bindir_len, bindir)) { + + const char *p2 = NULL; + +#ifdef ENABLE_MULTIARCH + multiarch: +#endif + if (p - libpath >= bindir_len && !STRNCASECMP(p - bindir_len, bindir, bindir_len)) { p -= bindir_len; - *p = 0; + archlibdir = rb_str_subseq(sopath, 0, p - libpath); + rb_str_cat_cstr(archlibdir, libdir); + OBJ_FREEZE_RAW(archlibdir); } - else if (p - libpath >= libdir_len && !STRCASECMP(p - libdir_len, libdir)) { + else if (p - libpath >= libdir_len && !strncmp(p - libdir_len, libdir, libdir_len)) { + archlibdir = rb_str_subseq(sopath, 0, (p2 ? p2 : p) - libpath); + OBJ_FREEZE_RAW(archlibdir); p -= libdir_len; - *p = 0; } +#ifdef ENABLE_MULTIARCH + else if (p2) { + p = p2; + } + else { + p2 = p; + p = rb_enc_path_last_separator(libpath, p, rb_ascii8bit_encoding()); + if (p) goto multiarch; + p = p2; + } +#endif + baselen = p - libpath; } -#if !VARIABLE_LIBPATH else { - strlcpy(libpath, ".", sizeof(libpath)); - p = libpath + 1; + baselen = 0; } - baselen = p - libpath; -#define PREFIX_PATH() rb_str_new(libpath, baselen) -#else - baselen = p - libpath; rb_str_resize(sopath, baselen); libpath = RSTRING_PTR(sopath); #define PREFIX_PATH() sopath -#endif - #define BASEPATH() rb_str_buf_cat(rb_str_buf_new(baselen+len), libpath, baselen) - #define RUBY_RELATIVE(path, len) rb_str_buf_cat(BASEPATH(), (path), (len)) #else - static const char exec_prefix[] = RUBY_EXEC_PREFIX; -#define RUBY_RELATIVE(path, len) rubylib_mangled_path((path), (len)) -#define PREFIX_PATH() RUBY_RELATIVE(exec_prefix, sizeof(exec_prefix)-1) + const size_t exec_prefix_len = strlen(ruby_exec_prefix); +#define RUBY_RELATIVE(path, len) rubylib_path_new((path), (len)) +#define PREFIX_PATH() RUBY_RELATIVE(ruby_exec_prefix, exec_prefix_len) #endif + rb_gc_register_address(&ruby_prefix_path); + ruby_prefix_path = PREFIX_PATH(); + OBJ_FREEZE_RAW(ruby_prefix_path); + if (!archlibdir) archlibdir = ruby_prefix_path; + rb_gc_register_address(&ruby_archlibdir_path); + ruby_archlibdir_path = archlibdir; + load_path = GET_VM()->load_path; - if (safe_level == 0) { -#ifdef MANGLED_PATH - rubylib_mangled_path("", 0); -#endif - ruby_push_include(getenv("RUBYLIB"), identical_path); - } + ruby_push_include(getenv("RUBYLIB"), identical_path); - id_initial_load_path_mark = rb_intern_const("@gem_prelude_index"); + id_initial_load_path_mark = INITIAL_LOAD_PATH_MARK; while (*paths) { size_t len = strlen(paths); VALUE path = RUBY_RELATIVE(paths, len); @@ -468,7 +761,7 @@ ruby_init_loadpath_safe(int safe_level) paths += len + 1; } - rb_const_set(rb_cObject, rb_intern_const("TMP_RUBY_PREFIX"), rb_obj_freeze(PREFIX_PATH())); + rb_const_set(rb_cObject, rb_intern_const("TMP_RUBY_PREFIX"), ruby_prefix_path); } @@ -479,11 +772,9 @@ add_modules(VALUE *req_list, const char *mod) VALUE feature; if (!list) { - *req_list = list = rb_ary_new(); - RBASIC(list)->klass = 0; + *req_list = list = rb_ary_tmp_new(0); } - feature = rb_str_new2(mod); - RBASIC(feature)->klass = 0; + feature = rb_str_cat_cstr(rb_str_tmp_new(0), mod); rb_ary_push(list, feature); } @@ -493,26 +784,23 @@ require_libraries(VALUE *req_list) VALUE list = *req_list; VALUE self = rb_vm_top_self(); ID require; - rb_thread_t *th = GET_THREAD(); - rb_block_t *prev_base_block = th->base_block; rb_encoding *extenc = rb_default_external_encoding(); - int prev_parse_in_eval = th->parse_in_eval; - th->base_block = 0; - th->parse_in_eval = 0; - Init_ext(); /* should be called here for some reason :-( */ CONST_ID(require, "require"); while (list && RARRAY_LEN(list) > 0) { VALUE feature = rb_ary_shift(list); rb_enc_associate(feature, extenc); - RBASIC(feature)->klass = rb_cString; + RBASIC_SET_CLASS_RAW(feature, rb_cString); OBJ_FREEZE(feature); - rb_funcall2(self, require, 1, &feature); + rb_funcallv(self, require, 1, &feature); } *req_list = 0; +} - th->parse_in_eval = prev_parse_in_eval; - th->base_block = prev_base_block; +static const struct rb_block* +toplevel_context(rb_binding_t *bind) +{ + return &bind->block; } static void @@ -520,11 +808,11 @@ process_sflag(int *sflag) { if (*sflag > 0) { long n; - VALUE *args; + const VALUE *args; VALUE argv = rb_argv; n = RARRAY_LEN(argv); - args = RARRAY_PTR(argv); + args = RARRAY_CONST_PTR(argv); while (n > 0) { VALUE v = *args++; char *s = StringValuePtr(v); @@ -579,23 +867,24 @@ process_sflag(int *sflag) } } -static long proc_options(long argc, char **argv, struct cmdline_options *opt, int envopt); +static long proc_options(long argc, char **argv, ruby_cmdline_options_t *opt, int envopt); static void -moreswitches(const char *s, struct cmdline_options *opt, int envopt) +moreswitches(const char *s, ruby_cmdline_options_t *opt, int envopt) { long argc, i, len; char **argv, *p; const char *ap = 0; VALUE argstr, argary; + void *ptr; while (ISSPACE(*s)) s++; if (!*s) return; - argstr = rb_str_tmp_new((len = strlen(s)) + 2); + argstr = rb_str_tmp_new((len = strlen(s)) + (envopt!=0)); argary = rb_str_tmp_new(0); p = RSTRING_PTR(argstr); - *p++ = ' '; + if (envopt) *p++ = ' '; memcpy(p, s, len + 1); ap = 0; rb_str_cat(argary, (char *)&ap, sizeof(ap)); @@ -610,9 +899,10 @@ moreswitches(const char *s, struct cmdline_options *opt, int envopt) argc = RSTRING_LEN(argary) / sizeof(ap); ap = 0; rb_str_cat(argary, (char *)&ap, sizeof(ap)); - argv = (char **)RSTRING_PTR(argary); + argv = ptr = ALLOC_N(char *, argc); + MEMMOVE(argv, RSTRING_PTR(argary), char *, argc); - while ((i = proc_options(argc, argv, opt, envopt)) > 1 && (argc -= i) > 0) { + while ((i = proc_options(argc, argv, opt, envopt)) > 1 && envopt && (argc -= i) > 0) { argv += i; if (**argv != '-') { *--*argv = '-'; @@ -623,13 +913,31 @@ moreswitches(const char *s, struct cmdline_options *opt, int envopt) } } + ruby_xfree(ptr); /* get rid of GC */ rb_str_resize(argary, 0); rb_str_resize(argstr, 0); } +static int +name_match_p(const char *name, const char *str, size_t len) +{ + if (len == 0) return 0; + while (1) { + while (TOLOWER(*str) == *name) { + if (!--len || !*++str) return 1; + ++name; + } + if (*str != '-' && *str != '_') return 0; + while (ISALNUM(*name)) name++; + if (*name != '-' && *name != '_') return 0; + ++name; + ++str; + } +} + #define NAME_MATCH_P(name, str, len) \ - ((len) < (int)sizeof(name) && strncmp((str), (name), (len)) == 0) + ((len) < (int)sizeof(name) && name_match_p((name), (str), (len))) #define UNSET_WHEN(name, bit, str, len) \ if (NAME_MATCH_P((name), (str), (len))) { \ @@ -643,46 +951,109 @@ moreswitches(const char *s, struct cmdline_options *opt, int envopt) return; \ } +#define LITERAL_NAME_ELEMENT(name) #name + static void -enable_option(const char *str, int len, void *arg) +feature_option(const char *str, int len, void *arg, const unsigned int enable) { -#define UNSET_WHEN_DISABLE(bit) UNSET_WHEN(#bit, DISABLE_BIT(bit), str, len) - UNSET_WHEN_DISABLE(gems); - UNSET_WHEN_DISABLE(rubyopt); + static const char list[] = EACH_FEATURES(LITERAL_NAME_ELEMENT, ", "); + ruby_features_t *argp = arg; + unsigned int mask = ~0U; + unsigned int set = 0U; +#if AMBIGUOUS_FEATURE_NAMES + int matched = 0; +# define FEATURE_FOUND ++matched +#else +# define FEATURE_FOUND goto found +#endif +#define SET_FEATURE(bit) \ + if (NAME_MATCH_P(#bit, str, len)) {set |= mask = FEATURE_BIT(bit); FEATURE_FOUND;} + EACH_FEATURES(SET_FEATURE, ;); + if (NAME_MATCH_P("jit", str, len)) { // This allows you to cancel --jit +#if defined(MJIT_FORCE_ENABLE) || !YJIT_SUPPORTED_P + set |= mask = FEATURE_BIT(mjit); +#else + set |= mask = FEATURE_BIT(yjit); +#endif + goto found; + } if (NAME_MATCH_P("all", str, len)) { - *(unsigned int *)arg = 0U; - return; + // YJIT and MJIT cannot be enabled at the same time. We enable only YJIT for --enable=all. +#if defined(MJIT_FORCE_ENABLE) || !YJIT_SUPPORTED_P + mask &= ~(FEATURE_BIT(yjit)); +#else + mask &= ~(FEATURE_BIT(mjit)); +#endif + goto found; + } +#if AMBIGUOUS_FEATURE_NAMES + if (matched == 1) goto found; + if (matched > 1) { + VALUE mesg = rb_sprintf("ambiguous feature: `%.*s' (", len, str); +#define ADD_FEATURE_NAME(bit) \ + if (FEATURE_BIT(bit) & set) { \ + rb_str_cat_cstr(mesg, #bit); \ + if (--matched) rb_str_cat_cstr(mesg, ", "); \ + } + EACH_FEATURES(ADD_FEATURE_NAME, ;); + rb_str_cat_cstr(mesg, ")"); + rb_exc_raise(rb_exc_new_str(rb_eRuntimeError, mesg)); +#undef ADD_FEATURE_NAME } - rb_warn("unknown argument for --enable: `%.*s'", len, str); +#else + (void)set; +#endif + rb_warn("unknown argument for --%s: `%.*s'", + enable ? "enable" : "disable", len, str); + rb_warn("features are [%.*s].", (int)strlen(list), list); + return; + + found: + FEATURE_SET_TO(*argp, mask, (mask & enable)); + return; +} + +static void +enable_option(const char *str, int len, void *arg) +{ + feature_option(str, len, arg, ~0U); } static void disable_option(const char *str, int len, void *arg) { -#define SET_WHEN_DISABLE(bit) SET_WHEN(#bit, DISABLE_BIT(bit), str, len) - SET_WHEN_DISABLE(gems); - SET_WHEN_DISABLE(rubyopt); - if (NAME_MATCH_P("all", str, len)) { - *(unsigned int *)arg = ~0U; - return; - } - rb_warn("unknown argument for --disable: `%.*s'", len, str); + feature_option(str, len, arg, 0U); +} + +RUBY_EXTERN const int ruby_patchlevel; +int ruby_env_debug_option(const char *str, int len, void *arg); + +static void +debug_option(const char *str, int len, void *arg) +{ + static const char list[] = EACH_DEBUG_FEATURES(LITERAL_NAME_ELEMENT, ", "); + ruby_features_t *argp = arg; +#define SET_WHEN_DEBUG(bit) \ + if (NAME_MATCH_P(#bit, str, len)) { \ + FEATURE_SET(*argp, DEBUG_BIT(bit)); \ + return; \ + } + EACH_DEBUG_FEATURES(SET_WHEN_DEBUG, ;); +#ifdef RUBY_DEVEL + if (ruby_patchlevel < 0 && ruby_env_debug_option(str, len, 0)) return; +#endif + rb_warn("unknown argument for --debug: `%.*s'", len, str); + rb_warn("debug features are [%.*s].", (int)strlen(list), list); } static void dump_option(const char *str, int len, void *arg) { + static const char list[] = EACH_DUMPS(LITERAL_NAME_ELEMENT, ", "); #define SET_WHEN_DUMP(bit) SET_WHEN(#bit, DUMP_BIT(bit), str, len) - SET_WHEN_DUMP(version); - SET_WHEN_DUMP(copyright); - SET_WHEN_DUMP(usage); - SET_WHEN_DUMP(yydebug); - SET_WHEN_DUMP(syntax); - SET_WHEN_DUMP(parsetree); - SET_WHEN_DUMP(parsetree_with_comment); - SET_WHEN_DUMP(insns); + EACH_DUMPS(SET_WHEN_DUMP, ;); rb_warn("don't know how to dump `%.*s',", len, str); - rb_warn("but only [version, copyright, usage, yydebug, syntax, parsetree, parsetree_with_comment, insns]."); + rb_warn("but only [%.*s].", (int)strlen(list), list); } static void @@ -696,7 +1067,7 @@ set_option_encoding_once(const char *type, VALUE *name, const char *e, long elen if (*name && rb_funcall(ename, rb_intern("casecmp"), 1, *name) != INT2FIX(0)) { rb_raise(rb_eRuntimeError, - "%s already set to %s", type, RSTRING_PTR(*name)); + "%s already set to %"PRIsVALUE, type, *name); } *name = ename; } @@ -708,18 +1079,110 @@ set_option_encoding_once(const char *type, VALUE *name, const char *e, long elen #define set_source_encoding_once(opt, e, elen) \ set_option_encoding_once("source", &(opt)->src.enc.name, (e), (elen)) +#define opt_match(s, l, name) \ + ((((l) > rb_strlen_lit(name)) ? (s)[rb_strlen_lit(name)] == '=' : \ + (l) == rb_strlen_lit(name)) && \ + memcmp((s), name, rb_strlen_lit(name)) == 0 && \ + (((s) += rb_strlen_lit(name)), 1)) +#define opt_match_noarg(s, l, name) \ + opt_match(s, l, name) && (*(s) ? (rb_warn("argument to --jit-" name " is ignored"), 1) : 1) +#define opt_match_arg(s, l, name) \ + opt_match(s, l, name) && (*(s) ? 1 : (rb_raise(rb_eRuntimeError, "--jit-" name " needs an argument"), 0)) + +#define yjit_opt_match_noarg(s, l, name) \ + opt_match(s, l, name) && (*(s) ? (rb_warn("argument to --yjit-" name " is ignored"), 1) : 1) +#define yjit_opt_match_arg(s, l, name) \ + opt_match(s, l, name) && (*(s) && *(s+1) ? 1 : (rb_raise(rb_eRuntimeError, "--yjit-" name " needs an argument"), 0)) + +static bool +setup_yjit_options(const char *s, struct rb_yjit_options *yjit_opt) +{ + const char prefix[] = "yjit-"; + if (strncmp(prefix, s, sizeof(prefix)-1) != 0) { + return false; + } + s += sizeof(prefix)-1; + const size_t l = strlen(s); + if (l == 0) { + return false; + } + + if (yjit_opt_match_arg(s, l, "exec-mem-size")) { + yjit_opt->exec_mem_size = atoi(s + 1); + } + else if (yjit_opt_match_arg(s, l, "call-threshold")) { + yjit_opt->call_threshold = atoi(s + 1); + } + else if (yjit_opt_match_arg(s, l, "max-versions")) { + yjit_opt->max_versions = atoi(s + 1); + } + else if (yjit_opt_match_noarg(s, l, "greedy-versioning")) { + yjit_opt->greedy_versioning = true; + } + else if (yjit_opt_match_noarg(s, l, "no-type-prop")) { + yjit_opt->no_type_prop = true; + } + else if (yjit_opt_match_noarg(s, l, "stats")) { + yjit_opt->gen_stats = true; + } + else { + rb_raise(rb_eRuntimeError, + "invalid yjit option `%s' (--help will show valid yjit options)", s); + } + return true; +} + +#if USE_MJIT +static void +setup_mjit_options(const char *s, struct mjit_options *mjit_opt) +{ + if (*s != '-') return; + const size_t l = strlen(++s); + if (*s == 0) return; + else if (opt_match_noarg(s, l, "warnings")) { + mjit_opt->warnings = 1; + } + else if (opt_match(s, l, "debug")) { + if (*s) + mjit_opt->debug_flags = strdup(s + 1); + else + mjit_opt->debug = 1; + } + else if (opt_match_noarg(s, l, "wait")) { + mjit_opt->wait = 1; + } + else if (opt_match_noarg(s, l, "save-temps")) { + mjit_opt->save_temps = 1; + } + else if (opt_match(s, l, "verbose")) { + mjit_opt->verbose = *s ? atoi(s + 1) : 1; + } + else if (opt_match_arg(s, l, "max-cache")) { + mjit_opt->max_cache_size = atoi(s + 1); + } + else if (opt_match_arg(s, l, "min-calls")) { + mjit_opt->min_calls = atoi(s + 1); + } + else { + rb_raise(rb_eRuntimeError, + "invalid MJIT option `%s' (--help will show valid MJIT options)", s); + } +} +#endif + static long -proc_options(long argc, char **argv, struct cmdline_options *opt, int envopt) +proc_options(long argc, char **argv, ruby_cmdline_options_t *opt, int envopt) { long n, argc0 = argc; const char *s; + int warning = opt->warning; - if (argc == 0) + if (argc <= 0 || !argv) return 0; for (argc--, argv++; argc > 0; argc--, argv++) { const char *const arg = argv[0]; - if (arg[0] != '-' || !arg[1]) + if (!arg || arg[0] != '-' || !arg[1]) break; s = arg + 1; @@ -758,14 +1221,36 @@ proc_options(long argc, char **argv, struct cmdline_options *opt, int envopt) s++; goto reswitch; } - ruby_show_version(); + opt->dump |= DUMP_BIT(version_v); opt->verbose = 1; case 'w': - ruby_verbose = Qtrue; + if (!opt->warning) { + warning = 1; + ruby_verbose = Qtrue; + } + FEATURE_SET(opt->warn, RB_WARN_CATEGORY_ALL_BITS); s++; goto reswitch; case 'W': + if (s[1] == ':') { + unsigned int bits = 0; + static const char no_prefix[] = "no-"; + int enable = strncmp(s += 2, no_prefix, sizeof(no_prefix)-1) != 0; + if (!enable) s += sizeof(no_prefix)-1; + size_t len = strlen(s); + if (NAME_MATCH_P("deprecated", s, len)) { + bits = 1U << RB_WARN_CATEGORY_DEPRECATED; + } + else if (NAME_MATCH_P("experimental", s, len)) { + bits = 1U << RB_WARN_CATEGORY_EXPERIMENTAL; + } + else { + rb_warn("unknown warning category: `%s'", s); + } + if (bits) FEATURE_SET_TO(opt->warn, bits, enable ? bits : 0); + break; + } { size_t numlen; int v = 2; /* -W as -W2 */ @@ -773,18 +1258,32 @@ proc_options(long argc, char **argv, struct cmdline_options *opt, int envopt) if (*++s) { v = scan_oct(s, 1, &numlen); if (numlen == 0) - v = 1; + v = 2; s += numlen; } + if (!opt->warning) { + switch (v) { + case 0: + ruby_verbose = Qnil; + break; + case 1: + ruby_verbose = Qfalse; + break; + default: + ruby_verbose = Qtrue; + break; + } + } + warning = 1; switch (v) { case 0: - ruby_verbose = Qnil; + FEATURE_SET_TO(opt->warn, RB_WARN_CATEGORY_ALL_BITS, 0); break; case 1: - ruby_verbose = Qfalse; + FEATURE_SET_TO(opt->warn, 1U << RB_WARN_CATEGORY_DEPRECATED, 0); break; default: - ruby_verbose = Qtrue; + FEATURE_SET(opt->warn, RB_WARN_CATEGORY_ALL_BITS); break; } } @@ -826,11 +1325,9 @@ proc_options(long argc, char **argv, struct cmdline_options *opt, int envopt) if (envopt) goto noenvopt; forbid_setid("-e"); if (!*++s) { - s = argv[1]; - argc--, argv++; - } - if (!s) { - rb_raise(rb_eRuntimeError, "no code specified for -e"); + if (!--argc) + rb_raise(rb_eRuntimeError, "no code specified for -e"); + s = *++argv; } if (!opt->e_script) { opt->e_script = rb_str_new(0, 0); @@ -846,7 +1343,7 @@ proc_options(long argc, char **argv, struct cmdline_options *opt, int envopt) if (*++s) { add_modules(&opt->req_list, s); } - else if (argv[1]) { + else if (argc > 1) { add_modules(&opt->req_list, argv[1]); argc--, argv++; } @@ -860,6 +1357,7 @@ proc_options(long argc, char **argv, struct cmdline_options *opt, int envopt) case 'x': if (envopt) goto noenvopt; + forbid_setid("-x"); opt->xflag = TRUE; s++; if (*s && chdir(s) < 0) { @@ -870,12 +1368,7 @@ proc_options(long argc, char **argv, struct cmdline_options *opt, int envopt) case 'C': case 'X': if (envopt) goto noenvopt; - s++; - if (!*s) { - s = argv[1]; - argc--, argv++; - } - if (!s || !*s) { + if (!*++s && (!--argc || !(s = *++argv) || !*s)) { rb_fatal("Can't chdir"); } if (chdir(s) < 0) { @@ -927,26 +1420,11 @@ proc_options(long argc, char **argv, struct cmdline_options *opt, int envopt) } goto reswitch; - case 'T': - { - size_t numlen; - int v = 1; - - if (*++s) { - v = scan_oct(s, 2, &numlen); - if (numlen == 0) - v = 1; - s += numlen; - } - if (v > opt->safe_level) opt->safe_level = v; - } - goto reswitch; - case 'I': forbid_setid("-I"); if (*++s) ruby_incpush_expand(s); - else if (argv[1]) { + else if (argc > 1) { ruby_incpush_expand(argv[1]); argc--, argv++; } @@ -964,7 +1442,7 @@ proc_options(long argc, char **argv, struct cmdline_options *opt, int envopt) if (v > 0377) rb_rs = Qnil; else if (v == 0 && numlen >= 2) { - rb_rs = rb_str_new2("\n\n"); + rb_rs = rb_str_new2(""); } else { c = v & 0xff; @@ -985,27 +1463,35 @@ proc_options(long argc, char **argv, struct cmdline_options *opt, int envopt) # define check_envopt(name, allow_envopt) \ (((allow_envopt) || !envopt) ? (void)0 : \ rb_raise(rb_eRuntimeError, "invalid switch in RUBYOPT: --" name)) -# define need_argument(name, s) \ - ((*(s)++ ? !*(s) : (!--argc || !((s) = *++argv))) ? \ +# define need_argument(name, s, needs_arg, next_arg) \ + ((*(s) ? !*++(s) : (next_arg) && (!argc || !((s) = argv[1]) || (--argc, ++argv, 0))) && (needs_arg) ? \ rb_raise(rb_eRuntimeError, "missing argument for --" name) \ : (void)0) -# define is_option_with_arg(name, allow_hyphen, allow_envopt) \ +# define is_option_with_arg(name, allow_hyphen, allow_envopt) \ + is_option_with_optarg(name, allow_hyphen, allow_envopt, Qtrue, Qtrue) +# define is_option_with_optarg(name, allow_hyphen, allow_envopt, needs_arg, next_arg) \ (strncmp((name), s, n = sizeof(name) - 1) == 0 && is_option_end(s[n], (allow_hyphen)) ? \ - (check_envopt(name, (allow_envopt)), s += n, need_argument(name, s), 1) : 0) + (check_envopt(name, (allow_envopt)), s += n, \ + need_argument(name, s, needs_arg, next_arg), 1) : 0) if (strcmp("copyright", s) == 0) { if (envopt) goto noenvopt_long; opt->dump |= DUMP_BIT(copyright); } - else if (strcmp("debug", s) == 0) { - ruby_debug = Qtrue; - ruby_verbose = Qtrue; + else if (is_option_with_optarg("debug", Qtrue, Qtrue, Qfalse, Qfalse)) { + if (s && *s) { + ruby_each_words(s, debug_option, &opt->features); + } + else { + ruby_debug = Qtrue; + ruby_verbose = Qtrue; + } } else if (is_option_with_arg("enable", Qtrue, Qtrue)) { - ruby_each_words(s, enable_option, &opt->disable); + ruby_each_words(s, enable_option, &opt->features); } else if (is_option_with_arg("disable", Qtrue, Qtrue)) { - ruby_each_words(s, disable_option, &opt->disable); + ruby_each_words(s, disable_option, &opt->features); } else if (is_option_with_arg("encoding", Qfalse, Qtrue)) { char *p; @@ -1051,6 +1537,30 @@ proc_options(long argc, char **argv, struct cmdline_options *opt, int envopt) opt->verbose = 1; ruby_verbose = Qtrue; } + else if (strcmp("jit", s) == 0) { +#if !USE_MJIT + rb_warn("Ruby was built without JIT support"); +#elif defined(MJIT_FORCE_ENABLE) || !YJIT_SUPPORTED_P + FEATURE_SET(opt->features, FEATURE_BIT(mjit)); +#else + FEATURE_SET(opt->features, FEATURE_BIT(yjit)); +#endif + } + else if (strncmp("mjit", s, 4) == 0) { +#if USE_MJIT + FEATURE_SET(opt->features, FEATURE_BIT(mjit)); + setup_mjit_options(s + 4, &opt->mjit); +#else + rb_warn("MJIT support is disabled."); +#endif + } + else if (strcmp("yjit", s) == 0 || setup_yjit_options(s, &opt->yjit)) { +#if USE_MJIT + FEATURE_SET(opt->features, FEATURE_BIT(yjit)); +#else + rb_warn("Ruby was built without JIT support"); +#endif + } else if (strcmp("yydebug", s) == 0) { if (envopt) goto noenvopt_long; opt->dump |= DUMP_BIT(yydebug); @@ -1060,9 +1570,15 @@ proc_options(long argc, char **argv, struct cmdline_options *opt, int envopt) } else if (strcmp("help", s) == 0) { if (envopt) goto noenvopt_long; - opt->dump |= DUMP_BIT(usage); + opt->dump |= DUMP_BIT(help); goto switch_end; } + else if (is_option_with_arg("backtrace-limit", Qfalse, Qfalse)) { + char *e; + long n = strtol(s, &e, 10); + if (errno == ERANGE || n < 0 || *e) rb_raise(rb_eRuntimeError, "wrong limit for backtrace length"); + rb_backtrace_length_limit = n; + } else { rb_raise(rb_eRuntimeError, "invalid option --%s (-h will show valid options)", s); @@ -1075,16 +1591,9 @@ proc_options(long argc, char **argv, struct cmdline_options *opt, int envopt) default: { - if (ISPRINT(*s)) { - rb_raise(rb_eRuntimeError, + rb_raise(rb_eRuntimeError, "invalid option -%c (-h will show valid options)", (int)(unsigned char)*s); - } - else { - rb_raise(rb_eRuntimeError, - "invalid option -\\x%02X (-h will show valid options)", - (int)(unsigned char)*s); - } } goto switch_end; @@ -1103,20 +1612,51 @@ proc_options(long argc, char **argv, struct cmdline_options *opt, int envopt) # undef check_envopt # undef need_argument # undef is_option_with_arg +# undef is_option_with_optarg } } switch_end: + if (warning) opt->warning = warning; return argc0 - argc; } +void Init_builtin_features(void); + static void ruby_init_prelude(void) { - Init_prelude(); + Init_builtin_features(); rb_const_remove(rb_cObject, rb_intern_const("TMP_RUBY_PREFIX")); } +void rb_call_builtin_inits(void); + +static void +ruby_opt_init(ruby_cmdline_options_t *opt) +{ + if (opt->dump & dump_exit_bits) return; + + if (opt->features.set & FEATURE_BIT(gems)) { + rb_define_module("Gem"); + if (opt->features.set & FEATURE_BIT(error_highlight)) { + rb_define_module("ErrorHighlight"); + } + if (opt->features.set & FEATURE_BIT(did_you_mean)) { + rb_define_module("DidYouMean"); + } + } + + rb_warning_category_update(opt->warn.mask, opt->warn.set); + + Init_ext(); /* load statically linked extensions before rubygems */ + rb_call_builtin_inits(); + ruby_init_prelude(); + + ruby_set_script_name(opt->script_name); + require_libraries(&opt->req_list); +} + static int opt_enc_index(VALUE enc_name) { @@ -1132,17 +1672,19 @@ opt_enc_index(VALUE enc_name) return i; } -#define rb_progname (GET_VM()->progname) +#define rb_progname (GET_VM()->progname) +#define rb_orig_progname (GET_VM()->orig_progname) VALUE rb_argv0; +VALUE rb_e_script; static VALUE -false_value(void) +false_value(ID _x, VALUE *_y) { return Qfalse; } static VALUE -true_value(void) +true_value(ID _x, VALUE *_y) { return Qtrue; } @@ -1156,7 +1698,7 @@ uscore_get(void) VALUE line; line = rb_lastline_get(); - if (TYPE(line) != T_STRING) { + if (!RB_TYPE_P(line, T_STRING)) { rb_raise(rb_eTypeError, "$_ value need to be String (%s given)", NIL_P(line) ? "nil" : rb_obj_classname(line)); } @@ -1166,7 +1708,7 @@ uscore_get(void) /* * call-seq: * sub(pattern, replacement) -> $_ - * sub(pattern) { block } -> $_ + * sub(pattern) {|...| block } -> $_ * * Equivalent to <code>$_.sub(<i>args</i>)</code>, except that * <code>$_</code> will be updated if substitution occurs. @@ -1174,9 +1716,7 @@ uscore_get(void) */ static VALUE -rb_f_sub(argc, argv) - int argc; - VALUE *argv; +rb_f_sub(int argc, VALUE *argv, VALUE _) { VALUE str = rb_funcall_passing_block(uscore_get(), rb_intern("sub"), argc, argv); rb_lastline_set(str); @@ -1185,19 +1725,17 @@ rb_f_sub(argc, argv) /* * call-seq: - * gsub(pattern, replacement) -> string - * gsub(pattern) {|...| block } -> string + * gsub(pattern, replacement) -> $_ + * gsub(pattern) {|...| block } -> $_ * * Equivalent to <code>$_.gsub...</code>, except that <code>$_</code> - * receives the modified result. + * will be updated if substitution occurs. * Available only when -p/-n command line option specified. * */ static VALUE -rb_f_gsub(argc, argv) - int argc; - VALUE *argv; +rb_f_gsub(int argc, VALUE *argv, VALUE _) { VALUE str = rb_funcall_passing_block(uscore_get(), rb_intern("gsub"), argc, argv); rb_lastline_set(str); @@ -1206,16 +1744,16 @@ rb_f_gsub(argc, argv) /* * call-seq: - * chop -> string + * chop -> $_ * * Equivalent to <code>($_.dup).chop!</code>, except <code>nil</code> - * is never returned. See <code>String#chop!</code>. + * is never returned. See String#chop!. * Available only when -p/-n command line option specified. * */ static VALUE -rb_f_chop(void) +rb_f_chop(VALUE _) { VALUE str = rb_funcall_passing_block(uscore_get(), rb_intern("chop"), 0, 0); rb_lastline_set(str); @@ -1229,47 +1767,141 @@ rb_f_chop(void) * chomp(string) -> $_ * * Equivalent to <code>$_ = $_.chomp(<em>string</em>)</code>. See - * <code>String#chomp</code>. + * String#chomp. * Available only when -p/-n command line option specified. * */ static VALUE -rb_f_chomp(argc, argv) - int argc; - VALUE *argv; +rb_f_chomp(int argc, VALUE *argv, VALUE _) { VALUE str = rb_funcall_passing_block(uscore_get(), rb_intern("chomp"), argc, argv); rb_lastline_set(str); return str; } +static void +setup_pager_env(void) +{ + if (!getenv("LESS")) ruby_setenv("LESS", "-R"); // Output "raw" control characters. +} + +#ifdef _WIN32 +static int +tty_enabled(void) +{ + HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE); + DWORD m; + if (!GetConsoleMode(h, &m)) return 0; +# ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING +# define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x4 +# endif + if (!(m & ENABLE_VIRTUAL_TERMINAL_PROCESSING)) return 0; + return 1; +} +#elif !defined(HAVE_WORKING_FORK) +# define tty_enabled() 0 +#endif + +static VALUE +copy_str(VALUE str, rb_encoding *enc, bool intern) +{ + if (!intern) { + if (rb_enc_str_coderange_scan(str, enc) == ENC_CODERANGE_BROKEN) + return 0; + return rb_enc_associate(rb_str_dup(str), enc); + } + return rb_enc_interned_str(RSTRING_PTR(str), RSTRING_LEN(str), enc); +} + static VALUE -process_options(int argc, char **argv, struct cmdline_options *opt) +process_options(int argc, char **argv, ruby_cmdline_options_t *opt) { - NODE *tree = 0; + rb_ast_t *ast = 0; VALUE parser; - VALUE iseq; + VALUE script_name; + const rb_iseq_t *iseq; rb_encoding *enc, *lenc; +#if UTF8_PATH + rb_encoding *ienc = 0; + rb_encoding *const uenc = rb_utf8_encoding(); +#endif const char *s; char fbuf[MAXPATHLEN]; int i = (int)proc_options(argc, argv, opt, 0); - rb_thread_t *th = GET_THREAD(); - rb_env_t *env = 0; + unsigned int dump = opt->dump & dump_exit_bits; + rb_vm_t *vm = GET_VM(); + const long loaded_before_enc = RARRAY_LEN(vm->loaded_features); + + if (opt->dump & (DUMP_BIT(usage)|DUMP_BIT(help))) { + int tty = isatty(1); + const char *const progname = + (argc > 0 && argv && argv[0] ? argv[0] : + origarg.argc > 0 && origarg.argv && origarg.argv[0] ? origarg.argv[0] : + ruby_engine); + int columns = 0; + if ((opt->dump & DUMP_BIT(help)) && tty) { + const char *pager_env = getenv("RUBY_PAGER"); + if (!pager_env) pager_env = getenv("PAGER"); + if (pager_env && *pager_env && isatty(0)) { + const char *columns_env = getenv("COLUMNS"); + if (columns_env) columns = atoi(columns_env); + VALUE pager = rb_str_new_cstr(pager_env); +#ifdef HAVE_WORKING_FORK + int fds[2]; + if (rb_pipe(fds) == 0) { + rb_pid_t pid = rb_fork(); + if (pid > 0) { + /* exec PAGER with reading from child */ + dup2(fds[0], 0); + } + else if (pid == 0) { + /* send the help message to the parent PAGER */ + dup2(fds[1], 1); + dup2(fds[1], 2); + } + close(fds[0]); + close(fds[1]); + if (pid > 0) { + setup_pager_env(); + rb_f_exec(1, &pager); + kill(SIGTERM, pid); + rb_waitpid(pid, 0, 0); + } + } +#else + setup_pager_env(); + VALUE port = rb_io_popen(pager, rb_str_new_lit("w"), Qnil, Qnil); + if (!NIL_P(port)) { + int oldout = dup(1); + int olderr = dup(2); + int fd = RFILE(port)->fptr->fd; + tty = tty_enabled(); + dup2(fd, 1); + dup2(fd, 2); + usage(progname, 1, tty, columns); + fflush(stdout); + dup2(oldout, 1); + dup2(olderr, 2); + rb_io_close(port); + return Qtrue; + } +#endif + } + } + usage(progname, (opt->dump & DUMP_BIT(help)), tty, columns); + return Qtrue; + } argc -= i; argv += i; - if (opt->dump & DUMP_BIT(usage)) { - usage(origarg.argv[0]); - return Qtrue; - } - - if (!(opt->disable & DISABLE_BIT(rubyopt)) && - opt->safe_level == 0 && (s = getenv("RUBYOPT"))) { + if ((opt->features.set & FEATURE_BIT(rubyopt)) && (s = getenv("RUBYOPT"))) { VALUE src_enc_name = opt->src.enc.name; VALUE ext_enc_name = opt->ext.enc.name; VALUE int_enc_name = opt->intern.enc.name; + ruby_features_t feat = opt->features; + ruby_features_t warn = opt->warn; opt->src.enc.name = opt->ext.enc.name = opt->intern.enc.name = 0; moreswitches(s, opt, 1); @@ -1279,34 +1911,55 @@ process_options(int argc, char **argv, struct cmdline_options *opt) opt->ext.enc.name = ext_enc_name; if (int_enc_name) opt->intern.enc.name = int_enc_name; + FEATURE_SET_RESTORE(opt->features, feat); + FEATURE_SET_RESTORE(opt->warn, warn); } - if (opt->dump & DUMP_BIT(version)) { + if (opt->src.enc.name) + /* cannot set deprecated category, as enabling deprecation warnings based on flags + * has not happened yet. + */ + rb_warning("-K is specified; it is for 1.8 compatibility and may cause odd behavior"); + +#if USE_MJIT + if (opt->features.set & FEATURE_BIT(mjit)) { + opt->mjit.on = TRUE; /* set mjit.on for ruby_show_version() API and check to call mjit_init() */ + } +#endif + if (opt->features.set & FEATURE_BIT(yjit)) { +#if USE_MJIT + if (opt->mjit.on) { + rb_warn("MJIT and YJIT cannot both be enabled at the same time. Exiting"); + exit(1); + } +#endif + rb_yjit_init(&opt->yjit); + } + if (opt->dump & (DUMP_BIT(version) | DUMP_BIT(version_v))) { +#if USE_MJIT + mjit_opts.on = opt->mjit.on; /* used by ruby_show_version(). mjit_init() still can't be called here. */ +#endif ruby_show_version(); - return Qtrue; + if (opt->dump & DUMP_BIT(version)) return Qtrue; } if (opt->dump & DUMP_BIT(copyright)) { ruby_show_copyright(); - } - - if (opt->safe_level >= 4) { - OBJ_TAINT(rb_argv); - OBJ_TAINT(GET_VM()->load_path); + return Qtrue; } if (!opt->e_script) { - if (argc == 0) { /* no more args */ + if (argc <= 0) { /* no more args */ if (opt->verbose) return Qtrue; opt->script = "-"; } else { opt->script = argv[0]; - if (opt->script[0] == '\0') { + if (!opt->script || opt->script[0] == '\0') { opt->script = "-"; } else if (opt->do_search) { - char *path = getenv("RUBYPATH"); + const char *path = getenv("RUBYPATH"); opt->script = 0; if (path) { @@ -1321,16 +1974,31 @@ process_options(int argc, char **argv, struct cmdline_options *opt) argc--; argv++; } + if (opt->script[0] == '-' && !opt->script[1]) { + forbid_setid("program input from stdin"); + } } opt->script_name = rb_str_new_cstr(opt->script); opt->script = RSTRING_PTR(opt->script_name); -#if defined DOSISH || defined __CYGWIN__ + +#ifdef _WIN32 + translit_char_bin(RSTRING_PTR(opt->script_name), '\\', '/'); +#elif defined DOSISH translit_char(RSTRING_PTR(opt->script_name), '\\', '/'); #endif - ruby_init_loadpath_safe(opt->safe_level); - rb_enc_find_index("encdb"); + ruby_gc_set_params(); + ruby_init_loadpath(); + +#if USE_MJIT + if (opt->mjit.on) + /* Using TMP_RUBY_PREFIX created by ruby_init_loadpath(). */ + mjit_init(&opt->mjit); +#endif + + Init_ruby_description(); + Init_enc(); lenc = rb_locale_encoding(); rb_enc_associate(rb_progname, lenc); rb_obj_freeze(rb_progname); @@ -1352,50 +2020,82 @@ process_options(int argc, char **argv, struct cmdline_options *opt) enc = rb_enc_from_index(opt->ext.enc.index); } else { - enc = lenc; + enc = IF_UTF8_PATH(uenc, lenc); } rb_enc_set_default_external(rb_enc_from_encoding(enc)); if (opt->intern.enc.index >= 0) { enc = rb_enc_from_index(opt->intern.enc.index); rb_enc_set_default_internal(rb_enc_from_encoding(enc)); opt->intern.enc.index = -1; +#if UTF8_PATH + ienc = enc; +#endif } - rb_enc_associate(opt->script_name, lenc); + script_name = opt->script_name; + rb_enc_associate(opt->script_name, IF_UTF8_PATH(uenc, lenc)); +#if UTF8_PATH + if (uenc != lenc) { + opt->script_name = str_conv_enc(opt->script_name, uenc, lenc); + opt->script = RSTRING_PTR(opt->script_name); + } +#endif rb_obj_freeze(opt->script_name); - { + if (IF_UTF8_PATH(uenc != lenc, 1)) { long i; - VALUE load_path = GET_VM()->load_path; + VALUE load_path = vm->load_path; + const ID id_initial_load_path_mark = INITIAL_LOAD_PATH_MARK; + int modifiable = FALSE; + + rb_get_expanded_load_path(); for (i = 0; i < RARRAY_LEN(load_path); ++i) { - rb_enc_associate(RARRAY_PTR(load_path)[i], lenc); - } - } - if (!(opt->disable & DISABLE_BIT(gems))) { -#if defined DISABLE_RUBYGEMS && DISABLE_RUBYGEMS - rb_require("rubygems"); + VALUE path = RARRAY_AREF(load_path, i); + int mark = rb_attr_get(path, id_initial_load_path_mark) == path; +#if UTF8_PATH + VALUE newpath = rb_str_conv_enc(path, uenc, lenc); + if (newpath == path) continue; + path = newpath; #else - rb_define_module("Gem"); + if (!(path = copy_str(path, lenc, !mark))) continue; #endif + if (mark) rb_ivar_set(path, id_initial_load_path_mark, path); + if (!modifiable) { + rb_ary_modify(load_path); + modifiable = TRUE; + } + RARRAY_ASET(load_path, i, path); + } + if (modifiable) { + rb_ary_replace(vm->load_path_snapshot, load_path); + } } - ruby_init_prelude(); - ruby_set_argv(argc, argv); - process_sflag(&opt->sflag); - { - /* set eval context */ - VALUE toplevel_binding = rb_const_get(rb_cObject, rb_intern("TOPLEVEL_BINDING")); - rb_binding_t *bind; + VALUE loaded_features = vm->loaded_features; + bool modified = false; + for (long i = loaded_before_enc; i < RARRAY_LEN(loaded_features); ++i) { + VALUE path = RARRAY_AREF(loaded_features, i); + if (!(path = copy_str(path, IF_UTF8_PATH(uenc, lenc), true))) continue; + modified = true; + RARRAY_ASET(loaded_features, i, path); + } + if (modified) { + rb_ary_replace(vm->loaded_features_snapshot, loaded_features); + } + } - GetBindingPtr(toplevel_binding, bind); - GetEnvPtr(bind->env, env); + if (opt->features.mask & COMPILATION_FEATURES) { + VALUE option = rb_hash_new(); +#define SET_COMPILE_OPTION(h, o, name) \ + rb_hash_aset((h), ID2SYM(rb_intern_const(#name)), \ + RBOOL(FEATURE_SET_P(o->features, FEATURE_BIT(name)))); + SET_COMPILE_OPTION(option, opt, frozen_string_literal); + SET_COMPILE_OPTION(option, opt, debug_frozen_string_literal); + rb_funcallv(rb_cISeq, rb_intern_const("compile_option="), 1, &option); +#undef SET_COMPILE_OPTION } + ruby_set_argv(argc, argv); + process_sflag(&opt->sflag); -#define PREPARE_PARSE_MAIN(expr) do { \ - th->parse_in_eval--; \ - th->base_block = &env->block; \ - expr; \ - th->parse_in_eval++; \ - th->base_block = 0; \ -} while (0) + rb_parser_set_context(parser, 0, TRUE); if (opt->e_script) { VALUE progname = rb_progname; @@ -1405,34 +2105,38 @@ process_options(int argc, char **argv, struct cmdline_options *opt) } else { eenc = lenc; +#if UTF8_PATH + if (ienc) eenc = ienc; +#endif + } +#if UTF8_PATH + if (eenc != uenc) { + opt->e_script = str_conv_enc(opt->e_script, uenc, eenc); } +#endif rb_enc_associate(opt->e_script, eenc); - rb_vm_set_progname(rb_progname = opt->script_name); - require_libraries(&opt->req_list); - rb_vm_set_progname(rb_progname = progname); - - PREPARE_PARSE_MAIN({ - tree = rb_parser_compile_string(parser, opt->script, opt->e_script, 1); - }); + ruby_opt_init(opt); + ruby_set_script_name(progname); + rb_parser_set_options(parser, opt->do_print, opt->do_loop, + opt->do_line, opt->do_split); + ast = rb_parser_compile_string(parser, opt->script, opt->e_script, 1); } else { - if (opt->script[0] == '-' && !opt->script[1]) { - forbid_setid("program input from stdin"); - } - - PREPARE_PARSE_MAIN({ - tree = load_file(parser, opt->script, 1, opt); - }); + VALUE f; + f = open_load_file(script_name, &opt->xflag); + ast = load_file(parser, opt->script_name, f, 1, opt); + } + ruby_set_script_name(opt->script_name); + if (dump & DUMP_BIT(yydebug)) { + dump &= ~DUMP_BIT(yydebug); + if (!dump) return Qtrue; } - rb_progname = opt->script_name; - rb_vm_set_progname(rb_progname); - if (opt->dump & DUMP_BIT(yydebug)) return Qtrue; if (opt->ext.enc.index >= 0) { enc = rb_enc_from_index(opt->ext.enc.index); } else { - enc = lenc; + enc = IF_UTF8_PATH(uenc, lenc); } rb_enc_set_default_external(rb_enc_from_encoding(enc)); if (opt->intern.enc.index >= 0) { @@ -1445,117 +2149,135 @@ process_options(int argc, char **argv, struct cmdline_options *opt) rb_enc_set_default_internal(Qnil); rb_stdio_set_default_encoding(); - if (!tree) return Qfalse; + if (!ast->body.root) { + rb_ast_dispose(ast); + return Qfalse; + } process_sflag(&opt->sflag); opt->xflag = 0; - if (opt->safe_level >= 4) { - FL_UNSET(rb_argv, FL_TAINT); - FL_UNSET(GET_VM()->load_path, FL_TAINT); - } - - if (opt->dump & DUMP_BIT(syntax)) { + if (dump & DUMP_BIT(syntax)) { printf("Syntax OK\n"); - return Qtrue; + dump &= ~DUMP_BIT(syntax); + if (!dump) return Qtrue; } - if (opt->do_print) { - PREPARE_PARSE_MAIN({ - tree = rb_parser_append_print(parser, tree); - }); - } if (opt->do_loop) { - PREPARE_PARSE_MAIN({ - tree = rb_parser_while_loop(parser, tree, opt->do_line, opt->do_split); - }); rb_define_global_function("sub", rb_f_sub, -1); rb_define_global_function("gsub", rb_f_gsub, -1); rb_define_global_function("chop", rb_f_chop, 0); rb_define_global_function("chomp", rb_f_chomp, -1); } - if (opt->dump & DUMP_BIT(parsetree) || opt->dump & DUMP_BIT(parsetree_with_comment)) { - rb_io_write(rb_stdout, rb_parser_dump_tree(tree, opt->dump & DUMP_BIT(parsetree_with_comment))); + if (dump & (DUMP_BIT(parsetree)|DUMP_BIT(parsetree_with_comment))) { + rb_io_write(rb_stdout, rb_parser_dump_tree(ast->body.root, dump & DUMP_BIT(parsetree_with_comment))); rb_io_flush(rb_stdout); - return Qtrue; + dump &= ~DUMP_BIT(parsetree)&~DUMP_BIT(parsetree_with_comment); + if (!dump) { + rb_ast_dispose(ast); + return Qtrue; + } } - PREPARE_PARSE_MAIN({ + { VALUE path = Qnil; - if (!opt->e_script && strcmp(opt->script, "-")) - path = rb_realpath_internal(Qnil, opt->script_name, 1); - iseq = rb_iseq_new_main(tree, opt->script_name, path); - }); + if (!opt->e_script && strcmp(opt->script, "-")) { + path = rb_realpath_internal(Qnil, script_name, 1); +#if UTF8_PATH + if (uenc != lenc) { + path = str_conv_enc(path, uenc, lenc); + } +#endif + if (!ENCODING_GET(path)) { /* ASCII-8BIT */ + rb_enc_copy(path, opt->script_name); + } + } - if (opt->dump & DUMP_BIT(insns)) { - rb_io_write(rb_stdout, rb_iseq_disasm(iseq)); + rb_binding_t *toplevel_binding; + GetBindingPtr(rb_const_get(rb_cObject, rb_intern("TOPLEVEL_BINDING")), + toplevel_binding); + const struct rb_block *base_block = toplevel_context(toplevel_binding); + iseq = rb_iseq_new_main(&ast->body, opt->script_name, path, vm_block_iseq(base_block), !(dump & DUMP_BIT(insns_without_opt))); + rb_ast_dispose(ast); + } + + if (dump & (DUMP_BIT(insns) | DUMP_BIT(insns_without_opt))) { + rb_io_write(rb_stdout, rb_iseq_disasm((const rb_iseq_t *)iseq)); rb_io_flush(rb_stdout); - return Qtrue; + dump &= ~DUMP_BIT(insns); + if (!dump) return Qtrue; } + if (opt->dump & dump_exit_bits) return Qtrue; rb_define_readonly_boolean("$-p", opt->do_print); rb_define_readonly_boolean("$-l", opt->do_line); rb_define_readonly_boolean("$-a", opt->do_split); - rb_set_safe_level(opt->safe_level); - rb_gc_set_params(); + rb_gvar_ractor_local("$-p"); + rb_gvar_ractor_local("$-l"); + rb_gvar_ractor_local("$-a"); + + if ((rb_e_script = opt->e_script) != 0) { + rb_str_freeze(rb_e_script); + rb_gc_register_mark_object(opt->e_script); + } + + { + rb_execution_context_t *ec = GET_EC(); + + if (opt->e_script) { + /* -e */ + rb_exec_event_hook_script_compiled(ec, iseq, opt->e_script); + } + else { + /* file */ + rb_exec_event_hook_script_compiled(ec, iseq, Qnil); + } + } + return (VALUE)iseq; +} - return iseq; +#ifndef DOSISH +static void +warn_cr_in_shebang(const char *str, long len) +{ + if (str[len-1] == '\n' && str[len-2] == '\r') { + rb_warn("shebang line ending with \\r may cause problems"); + } } +#else +#define warn_cr_in_shebang(str, len) (void)0 +#endif struct load_file_arg { VALUE parser; - const char *fname; + VALUE fname; int script; - struct cmdline_options *opt; + ruby_cmdline_options_t *opt; + VALUE f; }; static VALUE -load_file_internal(VALUE arg) +load_file_internal(VALUE argp_v) { - extern VALUE rb_stdin; - struct load_file_arg *argp = (struct load_file_arg *)arg; + struct load_file_arg *argp = (struct load_file_arg *)argp_v; VALUE parser = argp->parser; - const char *fname = argp->fname; + VALUE orig_fname = argp->fname; int script = argp->script; - struct cmdline_options *opt = argp->opt; - VALUE f; + ruby_cmdline_options_t *opt = argp->opt; + VALUE f = argp->f; int line_start = 1; - NODE *tree = 0; + rb_ast_t *ast = 0; rb_encoding *enc; ID set_encoding; - int xflag = 0; - - if (!fname) - rb_load_fail(fname); - if (strcmp(fname, "-") == 0) { - f = rb_stdin; - } - else { - int fd, mode = O_RDONLY; -#if defined DOSISH || defined __CYGWIN__ - { - const char *ext = strrchr(fname, '.'); - if (ext && STRCASECMP(ext, ".exe") == 0) { - mode |= O_BINARY; - xflag = 1; - } - } -#endif - if ((fd = open(fname, mode)) < 0) { - rb_load_fail(fname); - } - rb_update_max_fd(fd); - - f = rb_io_fdopen(fd, mode, fname); - } CONST_ID(set_encoding, "set_encoding"); if (script) { VALUE c = 1; /* something not nil */ VALUE line; - char *p; + char *p, *str; + long len; int no_src_enc = !opt->src.enc.name; int no_ext_enc = !opt->ext.enc.name; int no_int_enc = !opt->intern.enc.name; @@ -1563,43 +2285,40 @@ load_file_internal(VALUE arg) enc = rb_ascii8bit_encoding(); rb_funcall(f, set_encoding, 1, rb_enc_from_encoding(enc)); - if (xflag || opt->xflag) { + if (opt->xflag) { line_start--; search_shebang: - forbid_setid("-x"); - opt->xflag = FALSE; while (!NIL_P(line = rb_io_gets(f))) { line_start++; - if (RSTRING_LEN(line) > 2 - && RSTRING_PTR(line)[0] == '#' - && RSTRING_PTR(line)[1] == '!') { - if ((p = strstr(RSTRING_PTR(line), "ruby")) != 0) { + RSTRING_GETMEM(line, str, len); + if (len > 2 && str[0] == '#' && str[1] == '!') { + if (line_start == 1) warn_cr_in_shebang(str, len); + if ((p = strstr(str+2, ruby_engine)) != 0) { goto start_read; } } } - rb_raise(rb_eLoadError, "no Ruby script found in input"); + rb_loaderror("no Ruby script found in input"); } c = rb_io_getbyte(f); if (c == INT2FIX('#')) { c = rb_io_getbyte(f); - if (c == INT2FIX('!')) { - line = rb_io_gets(f); - if (NIL_P(line)) - return 0; - - if ((p = strstr(RSTRING_PTR(line), "ruby")) == 0) { + if (c == INT2FIX('!') && !NIL_P(line = rb_io_gets(f))) { + RSTRING_GETMEM(line, str, len); + warn_cr_in_shebang(str, len); + if ((p = strstr(str, ruby_engine)) == 0) { /* not ruby script, assume -x flag */ goto search_shebang; } start_read: - p += 4; - RSTRING_PTR(line)[RSTRING_LEN(line) - 1] = '\0'; - if (RSTRING_PTR(line)[RSTRING_LEN(line) - 2] == '\r') - RSTRING_PTR(line)[RSTRING_LEN(line) - 2] = '\0'; + str += len - 1; + if (*str == '\n') *str-- = '\0'; + if (*str == '\r') *str-- = '\0'; + /* ruby_engine should not contain a space */ if ((p = strstr(p, " -")) != 0) { + opt->warning = 0; moreswitches(p + 1, opt, 0); } @@ -1624,12 +2343,10 @@ load_file_internal(VALUE arg) else if (!NIL_P(c)) { rb_io_ungetbyte(f, c); } - else { - if (f != rb_stdin) rb_io_close(f); - f = Qnil; + if (NIL_P(c)) { + argp->f = f = Qnil; } - rb_vm_set_progname(rb_progname = opt->script_name); - require_libraries(&opt->req_list); /* Why here? unnatural */ + ruby_opt_init(opt); } if (opt->src.enc.index >= 0) { enc = rb_enc_from_index(opt->src.enc.index); @@ -1638,17 +2355,19 @@ load_file_internal(VALUE arg) enc = rb_locale_encoding(); } else { - enc = rb_usascii_encoding(); + enc = rb_utf8_encoding(); } + rb_parser_set_options(parser, opt->do_print, opt->do_loop, + opt->do_line, opt->do_split); if (NIL_P(f)) { f = rb_str_new(0, 0); rb_enc_associate(f, enc); - return (VALUE)rb_parser_compile_string(parser, fname, f, line_start); + return (VALUE)rb_parser_compile_string_path(parser, orig_fname, f, line_start); } rb_funcall(f, set_encoding, 2, rb_enc_from_encoding(enc), rb_str_new_cstr("-")); - tree = rb_parser_compile_file(parser, fname, f, line_start); + ast = rb_parser_compile_file_path(parser, orig_fname, f, line_start); rb_funcall(f, set_encoding, 1, rb_parser_encoding(parser)); - if (script && tree && rb_parser_end_seen_p(parser)) { + if (script && rb_parser_end_seen_p(parser)) { /* * DATA is a File that contains the data section of the executed file. * To create a data section use <tt>__END__</tt>: @@ -1662,66 +2381,243 @@ load_file_internal(VALUE arg) * hello world! */ rb_define_global_const("DATA", f); + argp->f = Qnil; } - else if (f != rb_stdin) { - rb_io_close(f); + return (VALUE)ast; +} + +/* disabling O_NONBLOCK, and returns 0 on success, otherwise errno */ +static inline int +disable_nonblock(int fd) +{ +#if defined(HAVE_FCNTL) && defined(F_SETFL) + if (fcntl(fd, F_SETFL, 0) < 0) { + const int e = errno; + ASSUME(e != 0); +# if defined ENOTSUP + if (e == ENOTSUP) return 0; +# endif +# if defined B_UNSUPPORTED + if (e == B_UNSUPPORTED) return 0; +# endif + return e; } - return (VALUE)tree; +#endif + return 0; } static VALUE -restore_lineno(VALUE lineno) +open_load_file(VALUE fname_v, int *xflag) { - return rb_gv_set("$.", lineno); + const char *fname = (fname_v = rb_str_encode_ospath(fname_v), + StringValueCStr(fname_v)); + long flen = RSTRING_LEN(fname_v); + VALUE f; + int e; + + if (flen == 1 && fname[0] == '-') { + f = rb_stdin; + } + else { + int fd; + /* open(2) may block if fname is point to FIFO and it's empty. Let's + use O_NONBLOCK. */ +#if defined O_NONBLOCK && HAVE_FCNTL && !(O_NONBLOCK & O_ACCMODE) + /* TODO: fix conflicting O_NONBLOCK in ruby/win32.h */ +# define MODE_TO_LOAD (O_RDONLY | O_NONBLOCK) +#elif defined O_NDELAY && HAVE_FCNTL && !(O_NDELAY & O_ACCMODE) +# define MODE_TO_LOAD (O_RDONLY | O_NDELAY) +#else +# define MODE_TO_LOAD (O_RDONLY) +#endif + int mode = MODE_TO_LOAD; +#if defined DOSISH || defined __CYGWIN__ +# define isdirsep(x) ((x) == '/' || (x) == '\\') + { + static const char exeext[] = ".exe"; + enum {extlen = sizeof(exeext)-1}; + if (flen > extlen && !isdirsep(fname[flen-extlen-1]) && + STRNCASECMP(fname+flen-extlen, exeext, extlen) == 0) { + mode |= O_BINARY; + *xflag = 1; + } + } +#endif + + if ((fd = rb_cloexec_open(fname, mode, 0)) < 0) { + e = errno; + if (!rb_gc_for_fd(e)) { + rb_load_fail(fname_v, strerror(e)); + } + if ((fd = rb_cloexec_open(fname, mode, 0)) < 0) { + rb_load_fail(fname_v, strerror(errno)); + } + } + rb_update_max_fd(fd); + + if (MODE_TO_LOAD != O_RDONLY && (e = disable_nonblock(fd)) != 0) { + (void)close(fd); + rb_load_fail(fname_v, strerror(e)); + } + + e = ruby_is_fd_loadable(fd); + if (!e) { + e = errno; + (void)close(fd); + rb_load_fail(fname_v, strerror(e)); + } + + f = rb_io_fdopen(fd, mode, fname); + if (e < 0) { + /* + We need to wait if FIFO is empty. It's FIFO's semantics. + rb_thread_wait_fd() release GVL. So, it's safe. + */ + rb_io_wait(f, RB_INT2NUM(RUBY_IO_READABLE), Qnil); + } + } + return f; +} + +static VALUE +restore_load_file(VALUE arg) +{ + struct load_file_arg *argp = (struct load_file_arg *)arg; + VALUE f = argp->f; + + if (!NIL_P(f) && f != rb_stdin) { + rb_io_close(f); + } + return Qnil; } -static NODE * -load_file(VALUE parser, const char *fname, int script, struct cmdline_options *opt) +static rb_ast_t * +load_file(VALUE parser, VALUE fname, VALUE f, int script, ruby_cmdline_options_t *opt) { struct load_file_arg arg; arg.parser = parser; arg.fname = fname; arg.script = script; arg.opt = opt; - return (NODE *)rb_ensure(load_file_internal, (VALUE)&arg, restore_lineno, rb_gv_get("$.")); + arg.f = f; + return (rb_ast_t *)rb_ensure(load_file_internal, (VALUE)&arg, + restore_load_file, (VALUE)&arg); } void * rb_load_file(const char *fname) { - struct cmdline_options opt; + VALUE fname_v = rb_str_new_cstr(fname); + return rb_load_file_str(fname_v); +} - return load_file(rb_parser_new(), fname, 0, cmdline_options_init(&opt)); +void * +rb_load_file_str(VALUE fname_v) +{ + return rb_parser_load_file(rb_parser_new(), fname_v); } -static void -set_arg0(VALUE val, ID id) +void * +rb_parser_load_file(VALUE parser, VALUE fname_v) +{ + ruby_cmdline_options_t opt; + VALUE f = open_load_file(fname_v, &cmdline_options_init(&opt)->xflag); + return load_file(parser, fname_v, f, 0, &opt); +} + +/* + * call-seq: + * Process.argv0 -> frozen_string + * + * Returns the name of the script being executed. The value is not + * affected by assigning a new value to $0. + * + * This method first appeared in Ruby 2.1 to serve as a global + * variable free means to get the script name. + */ + +static VALUE +proc_argv0(VALUE process) +{ + return rb_orig_progname; +} + +static VALUE ruby_setproctitle(VALUE title); + +/* + * call-seq: + * Process.setproctitle(string) -> string + * + * Sets the process title that appears on the ps(1) command. Not + * necessarily effective on all platforms. No exception will be + * raised regardless of the result, nor will NotImplementedError be + * raised even if the platform does not support the feature. + * + * Calling this method does not affect the value of $0. + * + * Process.setproctitle('myapp: worker #%d' % worker_id) + * + * This method first appeared in Ruby 2.1 to serve as a global + * variable free means to change the process title. + */ + +static VALUE +proc_setproctitle(VALUE process, VALUE title) { - char *s; - long i; + return ruby_setproctitle(title); +} + +static VALUE +ruby_setproctitle(VALUE title) +{ + const char *ptr = StringValueCStr(title); + setproctitle("%.*s", RSTRING_LENINT(title), ptr); + return title; +} +static void +set_arg0(VALUE val, ID id, VALUE *_) +{ if (origarg.argv == 0) rb_raise(rb_eRuntimeError, "$0 not initialized"); - StringValue(val); - s = RSTRING_PTR(val); - i = RSTRING_LEN(val); - setproctitle("%.*s", (int)i, s); + rb_progname = rb_str_new_frozen(ruby_setproctitle(val)); +} - rb_progname = rb_obj_freeze(rb_external_str_new(s, i)); +static inline VALUE +external_str_new_cstr(const char *p) +{ +#if UTF8_PATH + VALUE str = rb_utf8_str_new_cstr(p); + str = str_conv_enc(str, NULL, rb_default_external_encoding()); + return str; +#else + return rb_external_str_new_cstr(p); +#endif } void ruby_script(const char *name) { if (name) { - rb_progname = rb_external_str_new(name, strlen(name)); + rb_orig_progname = rb_progname = external_str_new_cstr(name); rb_vm_set_progname(rb_progname); } } +/*! Sets the current script name to this value. + * + * Same as ruby_script() but accepts a VALUE. + */ +void +ruby_set_script_name(VALUE name) +{ + rb_orig_progname = rb_progname = rb_str_dup(name); + rb_vm_set_progname(rb_progname); +} + static void -init_ids(struct cmdline_options *opt) +init_ids(ruby_cmdline_options_t *opt) { rb_uid_t uid = getuid(); rb_uid_t euid = geteuid(); @@ -1730,61 +2626,84 @@ init_ids(struct cmdline_options *opt) if (uid != euid) opt->setids |= 1; if (egid != gid) opt->setids |= 2; - if (uid && opt->setids) { - if (opt->safe_level < 1) opt->safe_level = 1; - } } #undef forbid_setid static void -forbid_setid(const char *s, struct cmdline_options *opt) +forbid_setid(const char *s, const ruby_cmdline_options_t *opt) { if (opt->setids & 1) rb_raise(rb_eSecurityError, "no %s allowed while running setuid", s); if (opt->setids & 2) rb_raise(rb_eSecurityError, "no %s allowed while running setgid", s); - if (opt->safe_level > 0) - rb_raise(rb_eSecurityError, "no %s allowed in tainted mode", s); +} + +static VALUE +verbose_getter(ID id, VALUE *ptr) +{ + return *rb_ruby_verbose_ptr(); } static void -verbose_setter(VALUE val, ID id, void *data) +verbose_setter(VALUE val, ID id, VALUE *variable) { - VALUE *variable = data; - *variable = RTEST(val) ? Qtrue : val; + *rb_ruby_verbose_ptr() = RTEST(val) ? Qtrue : val; } static VALUE -opt_W_getter(ID id, void *data) +opt_W_getter(ID id, VALUE *dmy) { - VALUE *variable = data; - switch (*variable) { + VALUE v = *rb_ruby_verbose_ptr(); + + switch (v) { case Qnil: return INT2FIX(0); case Qfalse: return INT2FIX(1); case Qtrue: return INT2FIX(2); + default: + return Qnil; } - return Qnil; /* not reached */ +} + +static VALUE +debug_getter(ID id, VALUE *dmy) +{ + return *rb_ruby_debug_ptr(); +} + +static void +debug_setter(VALUE val, ID id, VALUE *dmy) +{ + *rb_ruby_debug_ptr() = val; } void ruby_prog_init(void) { - rb_define_hooked_variable("$VERBOSE", &ruby_verbose, 0, verbose_setter); - rb_define_hooked_variable("$-v", &ruby_verbose, 0, verbose_setter); - rb_define_hooked_variable("$-w", &ruby_verbose, 0, verbose_setter); - rb_define_hooked_variable("$-W", &ruby_verbose, opt_W_getter, rb_gvar_readonly_setter); - rb_define_variable("$DEBUG", &ruby_debug); - rb_define_variable("$-d", &ruby_debug); + rb_define_virtual_variable("$VERBOSE", verbose_getter, verbose_setter); + rb_define_virtual_variable("$-v", verbose_getter, verbose_setter); + rb_define_virtual_variable("$-w", verbose_getter, verbose_setter); + rb_define_virtual_variable("$-W", opt_W_getter, rb_gvar_readonly_setter); + rb_define_virtual_variable("$DEBUG", debug_getter, debug_setter); + rb_define_virtual_variable("$-d", debug_getter, debug_setter); + + rb_gvar_ractor_local("$VERBOSE"); + rb_gvar_ractor_local("$-v"); + rb_gvar_ractor_local("$-w"); + rb_gvar_ractor_local("$-W"); + rb_gvar_ractor_local("$DEBUG"); + rb_gvar_ractor_local("$-d"); rb_define_hooked_variable("$0", &rb_progname, 0, set_arg0); rb_define_hooked_variable("$PROGRAM_NAME", &rb_progname, 0, set_arg0); + rb_define_module_function(rb_mProcess, "argv0", proc_argv0, 0); + rb_define_module_function(rb_mProcess, "setproctitle", proc_setproctitle, 1); + /* - * ARGV contains the command line arguments used to run ruby with the - * first value containing the name of the executable. + * ARGV contains the command line arguments used to run ruby. * * A library like OptionParser can be used to process command-line * arguments. @@ -1798,15 +2717,9 @@ ruby_set_argv(int argc, char **argv) int i; VALUE av = rb_argv; -#if defined(USE_DLN_A_OUT) - if (origarg.argv) - dln_argv0 = origarg.argv[0]; - else - dln_argv0 = argv[0]; -#endif rb_ary_clear(av); for (i = 0; i < argc; i++) { - VALUE arg = rb_external_str_new_cstr(argv[i]); + VALUE arg = external_str_new_cstr(argv[i]); OBJ_FREEZE(arg); rb_ary_push(av, arg); @@ -1816,19 +2729,21 @@ ruby_set_argv(int argc, char **argv) void * ruby_process_options(int argc, char **argv) { - struct cmdline_options opt; + ruby_cmdline_options_t opt; VALUE iseq; + const char *script_name = (argc > 0 && argv[0]) ? argv[0] : ruby_engine; - ruby_script(argv[0]); /* for the time being */ + if (!origarg.argv || origarg.argc <= 0) { + origarg.argc = argc; + origarg.argv = argv; + } + ruby_script(script_name); /* for the time being */ rb_argv0 = rb_str_new4(rb_progname); rb_gc_register_mark_object(rb_argv0); iseq = process_options(argc, argv, cmdline_options_init(&opt)); #ifndef HAVE_SETPROCTITLE - { - extern void ruby_init_setproctitle(int argc, char *argv[]); - ruby_init_setproctitle(argc, argv); - } + ruby_init_setproctitle(argc, argv); #endif return (void*)(struct RData*)iseq; @@ -1868,13 +2783,11 @@ void ruby_sysinit(int *argc, char ***argv) { #if defined(_WIN32) - void rb_w32_sysinit(int *argc, char ***argv); rb_w32_sysinit(argc, argv); #endif - origarg.argc = *argc; - origarg.argv = *argv; -#if defined(USE_DLN_A_OUT) - dln_argv0 = origarg.argv[0]; -#endif + if (*argc >= 0 && *argv) { + origarg.argc = *argc; + origarg.argv = *argv; + } fill_standard_fds(); } |