Example #1
0
 private RubyArray match_array(Ruby runtime, int start) {
   check();
   if (regs == null) {
     if (start != 0) return runtime.newEmptyArray();
     if (begin == -1) {
       return runtime.newArray(runtime.getNil());
     } else {
       RubyString ss = makeShared(runtime, str, begin, end - begin);
       if (isTaint()) ss.setTaint(true);
       return runtime.newArray(ss);
     }
   } else {
     RubyArray arr = runtime.newArray(regs.numRegs - start);
     for (int i = start; i < regs.numRegs; i++) {
       if (regs.beg[i] == -1) {
         arr.append(runtime.getNil());
       } else {
         RubyString ss = makeShared(runtime, str, regs.beg[i], regs.end[i] - regs.beg[i]);
         if (isTaint()) ss.setTaint(true);
         arr.append(ss);
       }
     }
     return arr;
   }
 }
Example #2
0
  @JRubyMethod(compat = RUBY1_9)
  public IRubyObject primitive_errinfo(ThreadContext context) {
    Ruby runtime = context.runtime;

    RubyCoderResult lastResult = transcoder.getLastResult();

    // if we have not done anything, produce an empty errinfo
    if (lastResult == null) {
      return runtime.newArray(
          new IRubyObject[] {
            runtime.newSymbol("source_buffer_empty"),
            context.nil,
            context.nil,
            context.nil,
            context.nil
          });
    }

    RubyArray errinfo = RubyArray.newArray(context.runtime);

    if (!lastResult.isError()) {
      return runtime.newArray(
          new IRubyObject[] {
            runtime.newSymbol(lastResult.stringResult),
            context.nil,
            context.nil,
            context.nil,
            context.nil
          });
    } else {
      errinfo.append(runtime.newSymbol(lastResult.stringResult));

      // FIXME: gross
      errinfo.append(RubyString.newString(runtime, lastResult.inEncoding.getName()));
      errinfo.append(RubyString.newString(runtime, lastResult.outEncoding.getName()));

      if (lastResult.isError() && lastResult.errorBytes != null) {
        // FIXME: do this elsewhere and cache it
        ByteList errorBytes = new ByteList(lastResult.errorBytes, lastResult.inEncoding, true);
        errinfo.append(RubyString.newString(runtime, errorBytes));
      } else {
        errinfo.append(RubyString.newEmptyString(runtime));
      }

      if (lastResult.readagainBytes != null) {
        // FIXME: do this elsewhere and cache it
        ByteList readagainBytes =
            new ByteList(lastResult.readagainBytes, lastResult.inEncoding, true);
        errinfo.append(RubyString.newString(runtime, readagainBytes));
      } else {
        errinfo.append(RubyString.newEmptyString(runtime));
      }
    }

    return errinfo;
  }
Example #3
0
  @JRubyMethod
  public IRubyObject source_location(ThreadContext context) {
    Ruby runtime = context.runtime;
    if (file != null)
      return runtime.newArray(runtime.newString(file), runtime.newFixnum(line + 1 /*zero-based*/));

    if (block != null) {
      Binding binding = block.getBinding();
      return runtime.newArray(
          runtime.newString(binding.getFile()),
          runtime.newFixnum(binding.getLine() + 1 /*zero-based*/));
    }

    return runtime.getNil();
  }
Example #4
0
  @JRubyMethod(name = "source_location", compat = CompatVersion.RUBY1_9)
  public IRubyObject source_location(ThreadContext context) {
    Ruby runtime = context.getRuntime();
    if (sourcePosition != null) {
      return runtime.newArray(
          runtime.newString(sourcePosition.getFile()),
          runtime.newFixnum(sourcePosition.getLine() + 1 /*zero-based*/));
    } else if (block != null) {
      Binding binding = block.getBinding();
      return runtime.newArray(
          runtime.newString(binding.getFile()),
          runtime.newFixnum(binding.getLine() + 1 /*zero-based*/));
    }

    return runtime.getNil();
  }
Example #5
0
  @SuppressWarnings("unchecked")
  @JRubyMethod(name = "names")
  public IRubyObject names(ThreadContext context) {
    Ruby runtime = context.runtime;
    EncodingService service = runtime.getEncodingService();
    Entry entry = service.findEncodingOrAliasEntry(name);

    RubyArray result = runtime.newArray();
    HashEntryIterator i;
    i = service.getEncodings().entryIterator();
    while (i.hasNext()) {
      CaseInsensitiveBytesHash.CaseInsensitiveBytesHashEntry<Entry> e =
          ((CaseInsensitiveBytesHash.CaseInsensitiveBytesHashEntry<Entry>) i.next());
      if (e.value == entry) {
        result.append(
            RubyString.newUsAsciiStringShared(runtime, e.bytes, e.p, e.end - e.p).freeze(context));
      }
    }
    i = service.getAliases().entryIterator();
    while (i.hasNext()) {
      CaseInsensitiveBytesHash.CaseInsensitiveBytesHashEntry<Entry> e =
          ((CaseInsensitiveBytesHash.CaseInsensitiveBytesHashEntry<Entry>) i.next());
      if (e.value == entry) {
        result.append(
            RubyString.newUsAsciiStringShared(runtime, e.bytes, e.p, e.end - e.p).freeze(context));
      }
    }
    result.append(runtime.newString(EXTERNAL));
    result.append(runtime.newString(LOCALE));

    return result;
  }
Example #6
0
  @SuppressWarnings("unchecked")
  @JRubyMethod(name = "name_list", meta = true)
  public static IRubyObject name_list(ThreadContext context, IRubyObject recv) {
    Ruby runtime = context.runtime;
    EncodingService service = runtime.getEncodingService();

    RubyArray result =
        runtime.newArray(service.getEncodings().size() + service.getAliases().size());
    HashEntryIterator i;
    i = service.getEncodings().entryIterator();
    while (i.hasNext()) {
      CaseInsensitiveBytesHash.CaseInsensitiveBytesHashEntry<Entry> e =
          ((CaseInsensitiveBytesHash.CaseInsensitiveBytesHashEntry<Entry>) i.next());
      result.append(
          RubyString.newUsAsciiStringShared(runtime, e.bytes, e.p, e.end - e.p).freeze(context));
    }
    i = service.getAliases().entryIterator();
    while (i.hasNext()) {
      CaseInsensitiveBytesHash.CaseInsensitiveBytesHashEntry<Entry> e =
          ((CaseInsensitiveBytesHash.CaseInsensitiveBytesHashEntry<Entry>) i.next());
      result.append(
          RubyString.newUsAsciiStringShared(runtime, e.bytes, e.p, e.end - e.p).freeze(context));
    }

    result.append(runtime.newString(EXTERNAL));
    result.append(runtime.newString(LOCALE));

    return result;
  }
    public static IRubyObject newLocationArray(Ruby runtime, RubyStackTraceElement[] elements) {
      RubyArray ary = runtime.newArray(elements.length);

      for (RubyStackTraceElement element : elements) {
        ary.append(new RubyThread.Location(runtime, runtime.getLocation(), element));
      }

      return ary;
    }
Example #8
0
 @JRubyMethod(compat = CompatVersion.RUBY1_8)
 public IRubyObject select(ThreadContext context, Block block) {
   Ruby runtime = context.getRuntime();
   final RubyArray result;
   if (regs == null) {
     if (begin < 0) return runtime.newEmptyArray();
     IRubyObject s = str.substr(runtime, begin, end - begin);
     s.setTaint(isTaint());
     result = block.yield(context, s).isTrue() ? runtime.newArray(s) : runtime.newEmptyArray();
   } else {
     result = runtime.newArray();
     boolean taint = isTaint();
     for (int i = 0; i < regs.numRegs; i++) {
       IRubyObject s = str.substr(runtime, regs.beg[i], regs.end[i] - regs.beg[i]);
       if (taint) s.setTaint(true);
       if (block.yield(context, s).isTrue()) result.append(s);
     }
   }
   return result;
 }
Example #9
0
 private IRubyObject offsetCommon(ThreadContext context, int i, boolean is_19) {
   check();
   Ruby runtime = context.getRuntime();
   if (i < 0 || (regs == null ? 1 : regs.numRegs) <= i)
     throw runtime.newIndexError("index " + i + " out of matches");
   int b, e;
   if (regs == null) {
     b = begin;
     e = end;
   } else {
     b = regs.beg[i];
     e = regs.end[i];
   }
   if (b < 0) return runtime.newArray(runtime.getNil(), runtime.getNil());
   if (is_19 && !str.singleByteOptimizable()) {
     updateCharOffset();
     b = charOffsets.beg[i];
     e = charOffsets.end[i];
   }
   return runtime.newArray(RubyFixnum.newFixnum(runtime, b), RubyFixnum.newFixnum(runtime, e));
 }
Example #10
0
  public static void initARGV(Ruby runtime) {
    // define ARGV and $* for this runtime
    RubyArray argvArray = runtime.newArray();
    String[] argv = runtime.getInstanceConfig().getArgv();

    for (String arg : argv) {
      argvArray.append(RubyString.newInternalFromJavaExternal(runtime, arg));
    }

    if (runtime.getObject().getConstantNoConstMissing("ARGV") != null) {
      ((RubyArray) runtime.getObject().getConstant("ARGV")).replace(argvArray);
    } else {
      runtime.getObject().setConstantQuiet("ARGV", argvArray);
      runtime.getGlobalVariables().define("$*", new ValueAccessor(argvArray), GLOBAL);
    }
  }
Example #11
0
  @JRubyMethod(name = "first", compat = CompatVersion.RUBY1_9)
  public IRubyObject first(ThreadContext context, IRubyObject arg) {
    final Ruby runtime = context.getRuntime();
    final int num = RubyNumeric.num2int(arg);
    final RubyArray result = runtime.newArray(num);
    try {
      RubyEnumerable.callEach(
          runtime,
          context,
          this,
          new BlockCallback() {
            int n = num;

            public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) {
              if (n-- <= 0) throw JumpException.SPECIAL_JUMP;
              result.append(largs[0]);
              return runtime.getNil();
            }
          });
    } catch (JumpException.SpecialJump sj) {
    }
    return result;
  }
Example #12
0
 @JRubyMethod(
     name = "define_finalizer",
     required = 1,
     optional = 1,
     frame = true,
     module = true,
     visibility = Visibility.PRIVATE)
 public static IRubyObject define_finalizer(IRubyObject recv, IRubyObject[] args, Block block) {
   Ruby runtime = recv.getRuntime();
   IRubyObject finalizer = null;
   if (args.length == 2) {
     finalizer = args[1];
     if (!finalizer.respondsTo("call")) {
       throw runtime.newArgumentError(
           "wrong type argument " + finalizer.getType() + " (should be callable)");
     }
   } else {
     finalizer = runtime.newProc(Block.Type.PROC, block);
   }
   IRubyObject obj = args[0];
   runtime.getObjectSpace().addFinalizer(obj, finalizer);
   return runtime.newArray(runtime.newFixnum(runtime.getSafeLevel()), finalizer);
 }
Example #13
0
  public static void createGlobals(ThreadContext context, Ruby runtime) {
    runtime.defineGlobalConstant("TOPLEVEL_BINDING", runtime.newBinding());

    runtime.defineGlobalConstant("TRUE", runtime.getTrue());
    runtime.defineGlobalConstant("FALSE", runtime.getFalse());
    runtime.defineGlobalConstant("NIL", runtime.getNil());

    // define ARGV and $* for this runtime
    RubyArray argvArray = runtime.newArray();
    String[] argv = runtime.getInstanceConfig().getArgv();
    for (int i = 0; i < argv.length; i++) {
      argvArray.append(RubyString.newStringShared(runtime, argv[i].getBytes()));
    }
    runtime.defineGlobalConstant("ARGV", argvArray);
    runtime.getGlobalVariables().defineReadonly("$*", new ValueAccessor(argvArray));

    IAccessor d =
        new ValueAccessor(runtime.newString(runtime.getInstanceConfig().displayedFileName()));
    runtime.getGlobalVariables().define("$PROGRAM_NAME", d);
    runtime.getGlobalVariables().define("$0", d);

    // Version information:
    IRubyObject version = null;
    IRubyObject patchlevel = null;
    IRubyObject release = runtime.newString(Constants.COMPILE_DATE).freeze(context);
    IRubyObject platform = runtime.newString(Constants.PLATFORM).freeze(context);
    IRubyObject engine = runtime.newString(Constants.ENGINE).freeze(context);

    switch (runtime.getInstanceConfig().getCompatVersion()) {
      case RUBY1_8:
        version = runtime.newString(Constants.RUBY_VERSION).freeze(context);
        patchlevel = runtime.newFixnum(Constants.RUBY_PATCHLEVEL).freeze(context);
        break;
      case RUBY1_9:
        version = runtime.newString(Constants.RUBY1_9_VERSION).freeze(context);
        patchlevel = runtime.newFixnum(Constants.RUBY1_9_PATCHLEVEL).freeze(context);
        break;
    }
    runtime.defineGlobalConstant("RUBY_VERSION", version);
    runtime.defineGlobalConstant("RUBY_PATCHLEVEL", patchlevel);
    runtime.defineGlobalConstant("RUBY_RELEASE_DATE", release);
    runtime.defineGlobalConstant("RUBY_PLATFORM", platform);
    runtime.defineGlobalConstant("RUBY_ENGINE", engine);

    IRubyObject description =
        runtime.newString(runtime.getInstanceConfig().getVersionString()).freeze(context);
    runtime.defineGlobalConstant("RUBY_DESCRIPTION", description);

    IRubyObject copyright =
        runtime.newString(runtime.getInstanceConfig().getCopyrightString()).freeze(context);
    runtime.defineGlobalConstant("RUBY_COPYRIGHT", copyright);

    runtime.defineGlobalConstant("VERSION", version);
    runtime.defineGlobalConstant("RELEASE_DATE", release);
    runtime.defineGlobalConstant("PLATFORM", platform);

    IRubyObject jrubyVersion = runtime.newString(Constants.VERSION).freeze(context);
    IRubyObject jrubyRevision = runtime.newString(Constants.REVISION).freeze(context);
    runtime.defineGlobalConstant("JRUBY_VERSION", jrubyVersion);
    runtime.defineGlobalConstant("JRUBY_REVISION", jrubyRevision);

    if (runtime.is1_9()) {
      // needs to be a fixnum, but our revision is a sha1 hash from git
      runtime.defineGlobalConstant("RUBY_REVISION", runtime.newFixnum(Constants.RUBY1_9_REVISION));
    }

    GlobalVariable kcodeGV = new KCodeGlobalVariable(runtime, "$KCODE", runtime.newString("NONE"));
    runtime.defineVariable(kcodeGV);
    runtime.defineVariable(new GlobalVariable.Copy(runtime, "$-K", kcodeGV));
    IRubyObject defaultRS =
        runtime.newString(runtime.getInstanceConfig().getRecordSeparator()).freeze(context);
    GlobalVariable rs = new StringGlobalVariable(runtime, "$/", defaultRS);
    runtime.defineVariable(rs);
    runtime.setRecordSeparatorVar(rs);
    runtime.getGlobalVariables().setDefaultSeparator(defaultRS);
    runtime.defineVariable(new StringGlobalVariable(runtime, "$\\", runtime.getNil()));
    runtime.defineVariable(new StringGlobalVariable(runtime, "$,", runtime.getNil()));

    runtime.defineVariable(new LineNumberGlobalVariable(runtime, "$."));
    runtime.defineVariable(new LastlineGlobalVariable(runtime, "$_"));
    runtime.defineVariable(new LastExitStatusVariable(runtime, "$?"));

    runtime.defineVariable(new ErrorInfoGlobalVariable(runtime, "$!", runtime.getNil()));
    runtime.defineVariable(new NonEffectiveGlobalVariable(runtime, "$=", runtime.getFalse()));

    if (runtime.getInstanceConfig().getInputFieldSeparator() == null) {
      runtime.defineVariable(new GlobalVariable(runtime, "$;", runtime.getNil()));
    } else {
      runtime.defineVariable(
          new GlobalVariable(
              runtime,
              "$;",
              RubyRegexp.newRegexp(
                  runtime, runtime.getInstanceConfig().getInputFieldSeparator(), 0)));
    }

    Boolean verbose = runtime.getInstanceConfig().getVerbose();
    IRubyObject verboseValue = null;
    if (verbose == null) {
      verboseValue = runtime.getNil();
    } else if (verbose == Boolean.TRUE) {
      verboseValue = runtime.getTrue();
    } else {
      verboseValue = runtime.getFalse();
    }
    runtime.defineVariable(new VerboseGlobalVariable(runtime, "$VERBOSE", verboseValue));

    IRubyObject debug = runtime.newBoolean(runtime.getInstanceConfig().isDebug());
    runtime.defineVariable(new DebugGlobalVariable(runtime, "$DEBUG", debug));
    runtime.defineVariable(new DebugGlobalVariable(runtime, "$-d", debug));

    runtime.defineVariable(new SafeGlobalVariable(runtime, "$SAFE"));

    runtime.defineVariable(new BacktraceGlobalVariable(runtime, "$@"));

    IRubyObject stdin = new RubyIO(runtime, STDIO.IN);
    IRubyObject stdout = new RubyIO(runtime, STDIO.OUT);
    IRubyObject stderr = new RubyIO(runtime, STDIO.ERR);

    runtime.defineVariable(new InputGlobalVariable(runtime, "$stdin", stdin));

    runtime.defineVariable(new OutputGlobalVariable(runtime, "$stdout", stdout));
    runtime.getGlobalVariables().alias("$>", "$stdout");
    runtime.getGlobalVariables().alias("$defout", "$stdout");

    runtime.defineVariable(new OutputGlobalVariable(runtime, "$stderr", stderr));
    runtime.getGlobalVariables().alias("$deferr", "$stderr");

    runtime.defineGlobalConstant("STDIN", stdin);
    runtime.defineGlobalConstant("STDOUT", stdout);
    runtime.defineGlobalConstant("STDERR", stderr);

    runtime.defineVariable(new LoadedFeatures(runtime, "$\""));
    runtime.defineVariable(new LoadedFeatures(runtime, "$LOADED_FEATURES"));

    runtime.defineVariable(new LoadPath(runtime, "$:"));
    runtime.defineVariable(new LoadPath(runtime, "$-I"));
    runtime.defineVariable(new LoadPath(runtime, "$LOAD_PATH"));

    runtime.defineVariable(new MatchMatchGlobalVariable(runtime, "$&"));
    runtime.defineVariable(new PreMatchGlobalVariable(runtime, "$`"));
    runtime.defineVariable(new PostMatchGlobalVariable(runtime, "$'"));
    runtime.defineVariable(new LastMatchGlobalVariable(runtime, "$+"));
    runtime.defineVariable(new BackRefGlobalVariable(runtime, "$~"));

    // On platforms without a c-library accessable through JNA, getpid will return hashCode
    // as $$ used to. Using $$ to kill processes could take down many runtimes, but by basing
    // $$ on getpid() where available, we have the same semantics as MRI.
    runtime.getGlobalVariables().defineReadonly("$$", new PidAccessor(runtime));

    // after defn of $stderr as the call may produce warnings
    defineGlobalEnvConstants(runtime);

    // Fixme: Do we need the check or does Main.java not call this...they should consolidate
    if (runtime.getGlobalVariables().get("$*").isNil()) {
      runtime.getGlobalVariables().defineReadonly("$*", new ValueAccessor(runtime.newArray()));
    }

    runtime
        .getGlobalVariables()
        .defineReadonly(
            "$-p",
            new ValueAccessor(runtime.newBoolean(runtime.getInstanceConfig().isAssumePrinting())));
    runtime
        .getGlobalVariables()
        .defineReadonly(
            "$-a", new ValueAccessor(runtime.newBoolean(runtime.getInstanceConfig().isSplit())));
    runtime
        .getGlobalVariables()
        .defineReadonly(
            "$-l",
            new ValueAccessor(runtime.newBoolean(runtime.getInstanceConfig().isProcessLineEnds())));

    // ARGF, $< object
    RubyArgsFile.initArgsFile(runtime);
  }
Example #14
0
  public static void createGlobals(ThreadContext context, Ruby runtime) {
    GlobalVariables globals = runtime.getGlobalVariables();

    runtime.defineGlobalConstant("TOPLEVEL_BINDING", runtime.newBinding());

    runtime.defineGlobalConstant("TRUE", runtime.getTrue());
    runtime.defineGlobalConstant("FALSE", runtime.getFalse());
    runtime.defineGlobalConstant("NIL", runtime.getNil());

    initARGV(runtime);

    IAccessor d =
        new ValueAccessor(runtime.newString(runtime.getInstanceConfig().displayedFileName()));
    globals.define("$PROGRAM_NAME", d, GLOBAL);
    globals.define("$0", d, GLOBAL);

    // Version information:
    IRubyObject version = null;
    IRubyObject patchlevel = null;
    IRubyObject release = runtime.newString(Constants.COMPILE_DATE).freeze(context);
    IRubyObject platform = runtime.newString(Constants.PLATFORM).freeze(context);
    IRubyObject engine = runtime.newString(Constants.ENGINE).freeze(context);

    version = runtime.newString(Constants.RUBY_VERSION).freeze(context);
    patchlevel = runtime.newFixnum(Constants.RUBY_PATCHLEVEL);
    runtime.defineGlobalConstant("RUBY_VERSION", version);
    runtime.defineGlobalConstant("RUBY_PATCHLEVEL", patchlevel);
    runtime.defineGlobalConstant("RUBY_RELEASE_DATE", release);
    runtime.defineGlobalConstant("RUBY_PLATFORM", platform);

    IRubyObject description = runtime.newString(OutputStrings.getVersionString()).freeze(context);
    runtime.defineGlobalConstant("RUBY_DESCRIPTION", description);

    IRubyObject copyright = runtime.newString(OutputStrings.getCopyrightString()).freeze(context);
    runtime.defineGlobalConstant("RUBY_COPYRIGHT", copyright);

    runtime.defineGlobalConstant("RELEASE_DATE", release);
    runtime.defineGlobalConstant("PLATFORM", platform);

    IRubyObject jrubyVersion = runtime.newString(Constants.VERSION).freeze(context);
    IRubyObject jrubyRevision = runtime.newString(Constants.REVISION).freeze(context);
    runtime.defineGlobalConstant("JRUBY_VERSION", jrubyVersion);
    runtime.defineGlobalConstant("JRUBY_REVISION", jrubyRevision);

    // needs to be a fixnum, but our revision is a sha1 hash from git
    runtime.defineGlobalConstant("RUBY_REVISION", runtime.newFixnum(Constants.RUBY_REVISION));
    runtime.defineGlobalConstant("RUBY_ENGINE", engine);
    runtime.defineGlobalConstant("RUBY_ENGINE_VERSION", jrubyVersion);

    RubyInstanceConfig.Verbosity verbosity = runtime.getInstanceConfig().getVerbosity();
    runtime.defineVariable(new WarningGlobalVariable(runtime, "$-W", verbosity), GLOBAL);

    final GlobalVariable kcodeGV;
    kcodeGV = new NonEffectiveGlobalVariable(runtime, "$KCODE", runtime.getNil());

    runtime.defineVariable(kcodeGV, GLOBAL);
    runtime.defineVariable(new GlobalVariable.Copy(runtime, "$-K", kcodeGV), GLOBAL);
    IRubyObject defaultRS =
        runtime.newString(runtime.getInstanceConfig().getRecordSeparator()).freeze(context);
    GlobalVariable rs = new StringGlobalVariable(runtime, "$/", defaultRS);
    runtime.defineVariable(rs, GLOBAL);
    runtime.setRecordSeparatorVar(rs);
    globals.setDefaultSeparator(defaultRS);
    runtime.defineVariable(new StringGlobalVariable(runtime, "$\\", runtime.getNil()), GLOBAL);
    runtime.defineVariable(new StringGlobalVariable(runtime, "$,", runtime.getNil()), GLOBAL);

    runtime.defineVariable(new LineNumberGlobalVariable(runtime, "$."), GLOBAL);
    runtime.defineVariable(new LastlineGlobalVariable(runtime, "$_"), FRAME);
    runtime.defineVariable(new LastExitStatusVariable(runtime, "$?"), THREAD);

    runtime.defineVariable(new ErrorInfoGlobalVariable(runtime, "$!", runtime.getNil()), THREAD);
    runtime.defineVariable(
        new NonEffectiveGlobalVariable(runtime, "$=", runtime.getFalse()), GLOBAL);

    if (runtime.getInstanceConfig().getInputFieldSeparator() == null) {
      runtime.defineVariable(new GlobalVariable(runtime, "$;", runtime.getNil()), GLOBAL);
    } else {
      runtime.defineVariable(
          new GlobalVariable(
              runtime,
              "$;",
              RubyRegexp.newRegexp(
                  runtime,
                  runtime.getInstanceConfig().getInputFieldSeparator(),
                  new RegexpOptions())),
          GLOBAL);
    }

    RubyInstanceConfig.Verbosity verbose = runtime.getInstanceConfig().getVerbosity();
    IRubyObject verboseValue = null;
    if (verbose == RubyInstanceConfig.Verbosity.NIL) {
      verboseValue = runtime.getNil();
    } else if (verbose == RubyInstanceConfig.Verbosity.TRUE) {
      verboseValue = runtime.getTrue();
    } else {
      verboseValue = runtime.getFalse();
    }
    runtime.defineVariable(new VerboseGlobalVariable(runtime, "$VERBOSE", verboseValue), GLOBAL);
    runtime.defineVariable(new VerboseGlobalVariable(runtime, "$-v", verboseValue), GLOBAL);
    runtime.defineVariable(new VerboseGlobalVariable(runtime, "$-w", verboseValue), GLOBAL);

    IRubyObject debug = runtime.newBoolean(runtime.getInstanceConfig().isDebug());
    runtime.defineVariable(new DebugGlobalVariable(runtime, "$DEBUG", debug), GLOBAL);
    runtime.defineVariable(new DebugGlobalVariable(runtime, "$-d", debug), GLOBAL);

    runtime.defineVariable(new SafeGlobalVariable(runtime, "$SAFE"), THREAD);

    runtime.defineVariable(new BacktraceGlobalVariable(runtime, "$@"), THREAD);

    IRubyObject stdin =
        RubyIO.prepStdio(
            runtime,
            runtime.getIn(),
            prepareStdioChannel(runtime, STDIO.IN, runtime.getIn()),
            OpenFile.READABLE,
            runtime.getIO(),
            "<STDIN>");
    IRubyObject stdout =
        RubyIO.prepStdio(
            runtime,
            runtime.getOut(),
            prepareStdioChannel(runtime, STDIO.OUT, runtime.getOut()),
            OpenFile.WRITABLE,
            runtime.getIO(),
            "<STDOUT>");
    IRubyObject stderr =
        RubyIO.prepStdio(
            runtime,
            runtime.getErr(),
            prepareStdioChannel(runtime, STDIO.ERR, runtime.getErr()),
            OpenFile.WRITABLE | OpenFile.SYNC,
            runtime.getIO(),
            "<STDERR>");

    runtime.defineVariable(new InputGlobalVariable(runtime, "$stdin", stdin), GLOBAL);
    runtime.defineVariable(new OutputGlobalVariable(runtime, "$stdout", stdout), GLOBAL);
    globals.alias("$>", "$stdout");
    runtime.defineVariable(new OutputGlobalVariable(runtime, "$stderr", stderr), GLOBAL);

    runtime.defineGlobalConstant("STDIN", stdin);
    runtime.defineGlobalConstant("STDOUT", stdout);
    runtime.defineGlobalConstant("STDERR", stderr);

    runtime.defineVariable(new LoadedFeatures(runtime, "$\""), GLOBAL);
    runtime.defineVariable(new LoadedFeatures(runtime, "$LOADED_FEATURES"), GLOBAL);

    runtime.defineVariable(new LoadPath(runtime, "$:"), GLOBAL);
    runtime.defineVariable(new LoadPath(runtime, "$-I"), GLOBAL);
    runtime.defineVariable(new LoadPath(runtime, "$LOAD_PATH"), GLOBAL);

    runtime.defineVariable(new MatchMatchGlobalVariable(runtime, "$&"), FRAME);
    runtime.defineVariable(new PreMatchGlobalVariable(runtime, "$`"), FRAME);
    runtime.defineVariable(new PostMatchGlobalVariable(runtime, "$'"), FRAME);
    runtime.defineVariable(new LastMatchGlobalVariable(runtime, "$+"), FRAME);
    runtime.defineVariable(new BackRefGlobalVariable(runtime, "$~"), FRAME);

    // On platforms without a c-library accessable through JNA, getpid will return hashCode
    // as $$ used to. Using $$ to kill processes could take down many runtimes, but by basing
    // $$ on getpid() where available, we have the same semantics as MRI.
    globals.defineReadonly("$$", new PidAccessor(runtime), GLOBAL);

    // after defn of $stderr as the call may produce warnings
    defineGlobalEnvConstants(runtime);

    // Fixme: Do we need the check or does Main.java not call this...they should consolidate
    if (globals.get("$*").isNil()) {
      globals.defineReadonly("$*", new ValueAccessor(runtime.newArray()), GLOBAL);
    }

    globals.defineReadonly(
        "$-p",
        new ValueAccessor(runtime.newBoolean(runtime.getInstanceConfig().isAssumePrinting())),
        GLOBAL);
    globals.defineReadonly(
        "$-a",
        new ValueAccessor(runtime.newBoolean(runtime.getInstanceConfig().isSplit())),
        GLOBAL);
    globals.defineReadonly(
        "$-l",
        new ValueAccessor(runtime.newBoolean(runtime.getInstanceConfig().isProcessLineEnds())),
        GLOBAL);

    // ARGF, $< object
    RubyArgsFile.initArgsFile(runtime);

    globals.alias("$-0", "$/");

    // Define aliases originally in the "English.rb" stdlib
    globals.alias("$ERROR_INFO", "$!");
    globals.alias("$ERROR_POSITION", "$@");
    globals.alias("$FS", "$;");
    globals.alias("$FIELD_SEPARATOR", "$;");
    globals.alias("$OFS", "$,");
    globals.alias("$OUTPUT_FIELD_SEPARATOR", "$,");
    globals.alias("$RS", "$/");
    globals.alias("$INPUT_RECORD_SEPARATOR", "$/");
    globals.alias("$ORS", "$\\");
    globals.alias("$OUTPUT_RECORD_SEPARATOR", "$\\");
    globals.alias("$NR", "$.");
    globals.alias("$INPUT_LINE_NUMBER", "$.");
    globals.alias("$LAST_READ_LINE", "$_");
    globals.alias("$DEFAULT_OUTPUT", "$>");
    globals.alias("$DEFAULT_INPUT", "$<");
    globals.alias("$PID", "$$");
    globals.alias("$PROCESS_ID", "$$");
    globals.alias("$CHILD_STATUS", "$?");
    globals.alias("$LAST_MATCH_INFO", "$~");
    globals.alias("$IGNORECASE", "$=");
    globals.alias("$ARGV", "$*");
    globals.alias("$MATCH", "$&");
    globals.alias("$PREMATCH", "$`");
    globals.alias("$POSTMATCH", "$'");
    globals.alias("$LAST_PAREN_MATCH", "$+");
  }