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; } }
@JRubyMethod(name = "_id2ref", required = 1, module = true, visibility = Visibility.PRIVATE) public static IRubyObject id2ref(IRubyObject recv, IRubyObject id) { Ruby runtime = id.getRuntime(); if (!(id instanceof RubyFixnum)) { throw recv.getRuntime().newTypeError(id, recv.getRuntime().getFixnum()); } RubyFixnum idFixnum = (RubyFixnum) id; long longId = idFixnum.getLongValue(); if (longId == 0) { return runtime.getFalse(); } else if (longId == 2) { return runtime.getTrue(); } else if (longId == 4) { return runtime.getNil(); } else if (longId % 2 != 0) { // odd return runtime.newFixnum((longId - 1) / 2); } else { if (runtime.isObjectSpaceEnabled()) { IRubyObject object = runtime.getObjectSpace().id2ref(longId); if (object == null) { return runtime.getNil(); } return object; } else { runtime .getWarnings() .warn("ObjectSpace is disabled; _id2ref only supports immediates, pass -X+O to enable"); return runtime.getNil(); } } }
private IRubyObject internalGets(ThreadContext context, IRubyObject[] args) { Ruby runtime = context.getRuntime(); if (pos < internal.getByteList().realSize && !eof) { boolean isParagraph = false; ByteList sep; if (args.length > 0) { if (args[0].isNil()) { ByteList buf = internal .getByteList() .makeShared((int) pos, internal.getByteList().realSize - (int) pos); pos += buf.realSize; return RubyString.newString(runtime, buf); } sep = args[0].convertToString().getByteList(); if (sep.realSize == 0) { isParagraph = true; sep = Stream.PARAGRAPH_SEPARATOR; } } else { sep = ((RubyString) runtime.getGlobalVariables().get("$/")).getByteList(); } ByteList ss = internal.getByteList(); if (isParagraph) { swallowLF(ss); if (pos == ss.realSize) { return runtime.getNil(); } } int ix = ss.indexOf(sep, (int) pos); ByteList add; if (-1 == ix) { ix = internal.getByteList().realSize; add = ByteList.EMPTY_BYTELIST; } else { add = isParagraph ? NEWLINE : sep; } ByteList line = new ByteList(ix - (int) pos + add.length()); line.append(internal.getByteList(), (int) pos, ix - (int) pos); line.append(add); pos = ix + add.realSize; lineno++; return RubyString.newString(runtime, line); } return runtime.getNil(); }
private static IRubyObject callCmpMethod( ThreadContext context, IRubyObject recv, IRubyObject other, IRubyObject returnValueOnError) { Ruby runtime = context.runtime; if (recv == other) return runtime.getTrue(); try { IRubyObject result = invokedynamic(context, recv, OP_CMP, other); // This is only to prevent throwing exceptions by cmperr - it has poor performance if (result.isNil()) { return returnValueOnError; } return RubyBoolean.newBoolean(runtime, cmpint(context, result, recv, other) == 0); } catch (RaiseException e) { if (e.getException().kind_of_p(context, runtime.getStandardError()).isTrue()) { // clear error info resulting from failure to compare (JRUBY-3292) context.setErrorInfo(runtime.getNil()); return returnValueOnError; } else { throw e; } } }
/** match_end */ @JRubyMethod(name = "end", compat = CompatVersion.RUBY1_8) public IRubyObject end(ThreadContext context, IRubyObject index) { int i = RubyNumeric.num2int(index); Ruby runtime = context.getRuntime(); int e = endCommon(runtime, i); return e < 0 ? runtime.getNil() : RubyFixnum.newFixnum(runtime, e); }
@JRubyMethod(name = "compatible?", meta = true) public static IRubyObject compatible_p( ThreadContext context, IRubyObject self, IRubyObject first, IRubyObject second) { Ruby runtime = context.runtime; Encoding enc = areCompatible(first, second); return enc == null ? runtime.getNil() : runtime.getEncodingService().getEncoding(enc); }
private synchronized IRubyObject status(Ruby runtime) { if (threadImpl.isAlive()) { return RubyString.newStringShared(runtime, status.get().bytes); } else if (exitingException != null) { return runtime.getNil(); } else { return runtime.getFalse(); } }
@JRubyMethod(name = "open", required = 1, optional = 2, frame = true, meta = true) public static IRubyObject open( final ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) throws IOException { Ruby runtime = recv.getRuntime(); IRubyObject level = runtime.getNil(); IRubyObject strategy = runtime.getNil(); if (args.length > 1) { level = args[1]; if (args.length > 2) strategy = args[2]; } IRubyObject io = RuntimeHelpers.invoke( context, runtime.getFile(), "open", args[0], runtime.newString("wb")); RubyGzipWriter gzio = newGzipWriter(recv, new IRubyObject[] {io, level, strategy}, block); return RubyGzipFile.wrapBlock(context, gzio, block); }
private static void defineGlobalEnvConstants(Ruby runtime) { Map environmentVariableMap = null; OSEnvironment environment = new OSEnvironment(); environmentVariableMap = environment.getEnvironmentVariableMap(runtime); if (environmentVariableMap == null) { // if the environment variables can't be obtained, define an empty ENV environmentVariableMap = new HashMap(); } StringOnlyRubyHash h1 = new StringOnlyRubyHash(runtime, environmentVariableMap, runtime.getNil()); h1.getSingletonClass().defineAnnotatedMethods(StringOnlyRubyHash.class); runtime.defineGlobalConstant("ENV", h1); // Define System.getProperties() in ENV_JAVA Map systemProps = environment.getSystemPropertiesMap(runtime); runtime.defineGlobalConstant( "ENV_JAVA", new StringOnlyRubyHash(runtime, systemProps, runtime.getNil())); }
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)); }
@JRubyMethod(name = "end", compat = CompatVersion.RUBY1_9) public IRubyObject end19(ThreadContext context, IRubyObject index) { int i = backrefNumber(index); Ruby runtime = context.getRuntime(); int e = endCommon(runtime, i); if (e < 0) return runtime.getNil(); if (!str.singleByteOptimizable()) { updateCharOffset(); e = charOffsets.end[i]; } return RubyFixnum.newFixnum(runtime, e); }
@JRubyMethod(name = "begin") public IRubyObject begin19(ThreadContext context, IRubyObject index) { int i = backrefNumber(index); Ruby runtime = context.runtime; int b = beginCommon(runtime, i); if (b < 0) return runtime.getNil(); if (!str.singleByteOptimizable()) { updateCharOffset(); b = charOffsets.beg[i]; } return RubyFixnum.newFixnum(runtime, b); }
@JRubyMethod(name = "each_byte", frame = true) public IRubyObject each_byte(ThreadContext context, Block block) { checkReadable(); Ruby runtime = context.getRuntime(); ByteList bytes = internal.getByteList(); // Check the length every iteration, since // the block can modify this string. while (pos < bytes.length()) { block.yield(context, runtime.newFixnum(bytes.get((int) pos++) & 0xFF)); } return runtime.getNil(); }
public void marshalTo(Ruby runtime, Object obj, RubyClass type, MarshalStream marshalStream) throws IOException { RubySystemCallError exc = (RubySystemCallError) obj; marshalStream.registerLinkTarget(exc); List<Variable<Object>> attrs = exc.getVariableList(); attrs.add( new VariableEntry<Object>( "mesg", exc.message == null ? runtime.getNil() : exc.message)); attrs.add(new VariableEntry<Object>("errno", exc.errno)); attrs.add(new VariableEntry<Object>("bt", exc.getBacktrace())); marshalStream.dumpVariables(attrs); }
public WarningGlobalVariable( Ruby runtime, String name, RubyInstanceConfig.Verbosity verbosity) { super( runtime, name, verbosity == RubyInstanceConfig.Verbosity.NIL ? RubyFixnum.newFixnum(runtime, 0) : verbosity == RubyInstanceConfig.Verbosity.FALSE ? RubyFixnum.newFixnum(runtime, 1) : verbosity == RubyInstanceConfig.Verbosity.TRUE ? RubyFixnum.newFixnum(runtime, 2) : runtime.getNil()); }
@SuppressWarnings("unchecked") private static void defineGlobalEnvConstants(Ruby runtime) { Map<RubyString, RubyString> environmentVariableMap = OSEnvironment.environmentVariableMap(runtime); RubyHash env = new CaseInsensitiveStringOnlyRubyHash( runtime, environmentVariableMap, runtime.getNil(), runtime.getInstanceConfig().isNativeEnabled() && runtime.getInstanceConfig().isUpdateNativeENVEnabled()); env.getSingletonClass().defineAnnotatedMethods(CaseInsensitiveStringOnlyRubyHash.class); runtime.defineGlobalConstant("ENV", env); runtime.setENV(env); // Define System.getProperties() in ENV_JAVA Map<RubyString, RubyString> systemPropertiesMap = OSEnvironment.systemPropertiesMap(runtime); RubyHash envJava = new ReadOnlySystemPropertiesHash(runtime, systemPropertiesMap, runtime.getNil()); envJava.setFrozen(true); runtime.defineGlobalConstant("ENV_JAVA", envJava); }
private static void fixnumDownto(ThreadContext context, long from, long to, Block block) { Ruby runtime = context.getRuntime(); if (block.getBody().getArgumentType() == BlockBody.ZERO_ARGS) { final IRubyObject nil = runtime.getNil(); for (long i = from; i >= to; i--) { block.yield(context, nil); } } else { for (long i = from; i >= to; i--) { block.yield(context, RubyFixnum.newFixnum(runtime, i)); } } }
@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(); }
private void fixnumEach(ThreadContext context, Ruby runtime, Block block) { long lim = ((RubyFixnum) end).getLongValue(); if (!isExclusive) lim++; if (block.getBody().getArgumentType() == BlockBody.ZERO_ARGS) { final IRubyObject nil = runtime.getNil(); for (long i = ((RubyFixnum) begin).getLongValue(); i < lim; i++) { block.yield(context, nil); } } else { for (long i = ((RubyFixnum) begin).getLongValue(); i < lim; i++) { block.yield(context, RubyFixnum.newFixnum(runtime, i)); } } }
@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(); }
// This returns a list of values in the order the names are defined (named capture local var // feature uses this). public IRubyObject[] getNamedBackrefValues(Ruby runtime) { if (pattern.numberOfNames() == 0) return NULL_ARRAY; IRubyObject[] values = new IRubyObject[pattern.numberOfNames()]; int j = 0; for (Iterator<NameEntry> i = pattern.namedBackrefIterator(); i.hasNext(); ) { NameEntry e = i.next(); int[] refs = e.getBackRefs(); int length = refs.length; values[j++] = length == 0 ? runtime.getNil() : RubyRegexp.nth_match(refs[length - 1], this); } return values; }
@JRubyMethod(name = "max", frame = true, compat = CompatVersion.RUBY1_9) public IRubyObject max(ThreadContext context, Block block) { if (block.isGiven() || isExclusive && !(end instanceof RubyNumeric)) { return RuntimeHelpers.invokeSuper(context, this, block); } else { int c = RubyComparable.cmpint(context, begin.callMethod(context, "<=>", end), begin, end); Ruby runtime = context.getRuntime(); if (isExclusive) { if (!(end instanceof RubyInteger)) throw runtime.newTypeError("cannot exclude non Integer end value"); if (c == 0) return runtime.getNil(); if (end instanceof RubyFixnum) return RubyFixnum.newFixnum(runtime, ((RubyFixnum) end).getLongValue() - 1); return end.callMethod(context, "-", RubyFixnum.one(runtime)); } return end; } }
private static void fixnumDownto(ThreadContext context, long from, long to, Block block) { // We must avoid "i--" integer overflow when (to == Long.MIN_VALUE). Ruby runtime = context.runtime; if (block.getBody().getArgumentType() == BlockBody.ZERO_ARGS) { IRubyObject nil = runtime.getNil(); long i; for (i = from; i > to; i--) { block.yield(context, nil); } if (i >= to) { block.yield(context, nil); } } else { long i; for (i = from; i > to; i--) { block.yield(context, RubyFixnum.newFixnum(runtime, i)); } if (i >= to) { block.yield(context, RubyFixnum.newFixnum(runtime, i)); } } }
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); }
private static RubyTime createTime(IRubyObject recv, IRubyObject[] args, boolean gmt) { Ruby runtime = recv.getRuntime(); int len = ARG_SIZE; Boolean isDst = null; DateTimeZone dtz; if (gmt) { dtz = DateTimeZone.UTC; } else if (args.length == 10 && args[9] instanceof RubyString) { dtz = getTimeZone(runtime, ((RubyString) args[9]).toString()); } else { dtz = getLocalTimeZone(runtime); } if (args.length == 10) { if (args[8] instanceof RubyBoolean) { isDst = ((RubyBoolean) args[8]).isTrue(); } args = new IRubyObject[] { args[5], args[4], args[3], args[2], args[1], args[0], runtime.getNil() }; } else { // MRI accepts additional wday argument which appears to be ignored. len = args.length; if (len < ARG_SIZE) { IRubyObject[] newArgs = new IRubyObject[ARG_SIZE]; System.arraycopy(args, 0, newArgs, 0, args.length); for (int i = len; i < ARG_SIZE; i++) { newArgs[i] = runtime.getNil(); } args = newArgs; len = ARG_SIZE; } } if (args[0] instanceof RubyString) { args[0] = RubyNumeric.str2inum(runtime, (RubyString) args[0], 10, false); } int year = (int) RubyNumeric.num2long(args[0]); int month = 1; if (len > 1) { if (!args[1].isNil()) { IRubyObject tmp = args[1].checkStringType(); if (!tmp.isNil()) { String monthString = tmp.toString().toLowerCase(); Integer monthInt = MONTHS_MAP.get(monthString); if (monthInt != null) { month = monthInt; } else { try { month = Integer.parseInt(monthString); } catch (NumberFormatException nfExcptn) { throw runtime.newArgumentError("Argument out of range."); } } } else { month = (int) RubyNumeric.num2long(args[1]); } } if (1 > month || month > 12) { throw runtime.newArgumentError("Argument out of range: for month: " + month); } } int[] int_args = {1, 0, 0, 0, 0, 0}; for (int i = 0; int_args.length >= i + 2; i++) { if (!args[i + 2].isNil()) { if (!(args[i + 2] instanceof RubyNumeric)) { args[i + 2] = args[i + 2].callMethod(runtime.getCurrentContext(), "to_i"); } long value = RubyNumeric.num2long(args[i + 2]); if (time_min[i] > value || value > time_max[i]) { throw runtime.newArgumentError("argument out of range."); } int_args[i] = (int) value; } } if (!runtime.is1_9()) { if (0 <= year && year < 39) { year += 2000; } else if (69 <= year && year < 139) { year += 1900; } } DateTime dt; // set up with min values and then add to allow rolling over try { dt = new DateTime(year, 1, 1, 0, 0, 0, 0, DateTimeZone.UTC); dt = dt.plusMonths(month - 1) .plusDays(int_args[0] - 1) .plusHours(int_args[1]) .plusMinutes(int_args[2]) .plusSeconds(int_args[3]); if (runtime.is1_9() && !args[5].isNil()) { double millis = RubyFloat.num2dbl(args[5]); int int_millis = (int) (millis * 1000) % 1000; dt = dt.plusMillis(int_millis); } dt = dt.withZoneRetainFields(dtz); // we might need to perform a DST correction if (isDst != null) { // the instant at which we will ask dtz what the difference between DST and // standard time is long offsetCalculationInstant = dt.getMillis(); // if we might be moving this time from !DST -> DST, the offset is assumed // to be the same as it was just before we last moved from DST -> !DST if (dtz.isStandardOffset(dt.getMillis())) { offsetCalculationInstant = dtz.previousTransition(offsetCalculationInstant); } int offset = dtz.getStandardOffset(offsetCalculationInstant) - dtz.getOffset(offsetCalculationInstant); if (!isDst && !dtz.isStandardOffset(dt.getMillis())) { dt = dt.minusMillis(offset); } if (isDst && dtz.isStandardOffset(dt.getMillis())) { dt = dt.plusMillis(offset); } } } catch (org.joda.time.IllegalFieldValueException e) { throw runtime.newArgumentError("time out of range"); } RubyTime time = new RubyTime(runtime, (RubyClass) recv, dt); // Ignores usec if 8 args (for compatibility with parsedate) or if not supplied. if (args.length != 8 && !args[6].isNil()) { int usec = int_args[4] % 1000; int msec = int_args[4] / 1000; if (int_args[4] < 0) { msec -= 1; usec += 1000; } time.dt = dt.withMillis(dt.getMillis() + msec); time.setUSec(usec); } time.callInit(IRubyObject.NULL_ARRAY, Block.NULL_BLOCK); return time; }
public RubyGzipFile(Ruby runtime, RubyClass type) { super(runtime, type); mtime = runtime.getNil(); }
public LastExitStatusVariable(Ruby runtime, String name) { super(runtime, name, runtime.getNil()); }
public LastMatchGlobalVariable(Ruby runtime, String name) { super(runtime, name, runtime.getNil()); }
public BackRefGlobalVariable(Ruby runtime, String name) { super(runtime, name, runtime.getNil()); }
private RubyRange(Ruby runtime, RubyClass klass) { super(runtime, klass); begin = end = runtime.getNil(); }