final int[] begLenInt(int len, int err) {
int beg = RubyNumeric.num2int(this.begin);
int end = RubyNumeric.num2int(this.end);
if (beg < 0) {
beg += len;
if (beg < 0) {
if (err != 0)
throw getRuntime()
.newRangeError(beg + ".." + (isExclusive ? "." : "") + end + " out of range");
return null;
}
}
if (err == 0 || err == 2) {
if (beg > len) {
if (err != 0)
throw getRuntime()
.newRangeError(beg + ".." + (isExclusive ? "." : "") + end + " out of range");
return null;
}
if (end > len) end = len;
}
if (end < 0) end += len;
if (!isExclusive) end++;
len = end - beg;
if (len < 0) len = 0;
return new int[] {beg, len};
}
@JRubyMethod(name = "seek", required = 1, optional = 1, frame = true)
public IRubyObject seek(IRubyObject[] args) {
// MRI 1.8.7 behavior:
// checkOpen();
checkFinalized();
long amount = RubyNumeric.num2long(args[0]);
int whence = Stream.SEEK_SET;
long newPosition = pos;
if (args.length > 1 && !args[0].isNil()) whence = RubyNumeric.fix2int(args[1]);
if (whence == Stream.SEEK_CUR) {
newPosition += amount;
} else if (whence == Stream.SEEK_END) {
newPosition = internal.getByteList().length() + amount;
} else {
newPosition = amount;
}
if (newPosition < 0) throw getRuntime().newErrnoEINVALError();
pos = newPosition;
eof = false;
return RubyFixnum.zero(getRuntime());
}
@JRubyMethod(required = 1, optional = 1)
public IRubyObject seek(ThreadContext context, IRubyObject[] args) {
Ruby runtime = context.runtime;
checkFrozen();
checkFinalized();
int offset = RubyNumeric.num2int(args[0]);
IRubyObject whence = context.nil;
if (args.length > 1 && !args[0].isNil()) whence = args[1];
checkOpen();
switch (whence.isNil() ? 0 : RubyNumeric.num2int(whence)) {
case 0:
break;
case 1:
offset += ptr.pos;
break;
case 2:
offset += ptr.string.size();
break;
default:
throw runtime.newErrnoEINVALError("invalid whence");
}
if (offset < 0) throw runtime.newErrnoEINVALError("invalid seek value");
ptr.pos = offset;
return RubyFixnum.zero(runtime);
}
@JRubyMethod(required = 1, optional = 1)
@Override
public IRubyObject seek(IRubyObject[] args) {
checkOpen();
checkFinalized();
long amount = RubyNumeric.num2long(args[0]);
int whence = Stream.SEEK_SET;
long newPosition = data.pos;
if (args.length > 1 && !args[0].isNil()) whence = RubyNumeric.fix2int(args[1]);
if (whence == Stream.SEEK_CUR) {
newPosition += amount;
} else if (whence == Stream.SEEK_END) {
newPosition = data.internal.getByteList().length() + amount;
} else if (whence == Stream.SEEK_SET) {
newPosition = amount;
} else {
throw getRuntime().newErrnoEINVALError("invalid whence");
}
if (newPosition < 0) throw getRuntime().newErrnoEINVALError("invalid seek value");
data.pos = newPosition;
data.eof = false;
return RubyFixnum.zero(getRuntime());
}
@JRubyMethod
public IRubyObject iconv(IRubyObject str, IRubyObject startArg, IRubyObject endArg) {
int start = 0;
int end = -1;
if (!startArg.isNil()) start = RubyNumeric.fix2int(startArg);
if (!endArg.isNil()) end = RubyNumeric.fix2int(endArg);
return iconv(str, start, end);
}
/** num_div */
@JRubyMethod(name = "div")
public IRubyObject div19(ThreadContext context, IRubyObject other) {
if (other instanceof RubyNumeric) {
RubyNumeric numeric = (RubyNumeric) other;
if (numeric.zero_p(context).isTrue()) {
throw context.runtime.newZeroDivisionError();
}
}
return callMethod(context, "/", other).callMethod(context, "floor");
}
@JRubyMethod
public IRubyObject getsockopt(ThreadContext context, IRubyObject lev, IRubyObject optname) {
int level = RubyNumeric.fix2int(lev);
int opt = RubyNumeric.fix2int(optname);
Ruby runtime = context.getRuntime();
try {
switch (SocketLevel.valueOf(level)) {
case SOL_IP:
case SOL_SOCKET:
case SOL_TCP:
case SOL_UDP:
switch (SocketOption.valueOf(opt)) {
case SO_BROADCAST:
return getBroadcast(runtime);
case SO_KEEPALIVE:
return getKeepAlive(runtime);
case SO_LINGER:
return getLinger(runtime);
case SO_OOBINLINE:
return getOOBInline(runtime);
case SO_RCVBUF:
return getRcvBuf(runtime);
case SO_REUSEADDR:
return getReuseAddr(runtime);
case SO_SNDBUF:
return getSndBuf(runtime);
case SO_RCVTIMEO:
case SO_SNDTIMEO:
return getTimeout(runtime);
case SO_TYPE:
return getSoType(runtime);
// Can't support the rest with Java
case SO_RCVLOWAT:
return number(runtime, 1);
case SO_SNDLOWAT:
return number(runtime, 2048);
case SO_DEBUG:
case SO_ERROR:
case SO_DONTROUTE:
case SO_TIMESTAMP:
return trueFalse(runtime, false);
default:
throw context.getRuntime().newErrnoENOPROTOOPTError();
}
default:
throw context.getRuntime().newErrnoENOPROTOOPTError();
}
} catch (IOException e) {
throw context.getRuntime().newErrnoENOPROTOOPTError();
}
}
@JRubyMethod(name = "read", optional = 1)
public IRubyObject read(IRubyObject[] args) throws IOException {
if (args.length == 0 || args[0].isNil()) {
ByteList val = new ByteList(10);
byte[] buffer = new byte[BUFF_SIZE];
int read = io.read(buffer);
while (read != -1) {
val.append(buffer, 0, read);
read = io.read(buffer);
}
return RubyString.newString(getRuntime(), val);
}
int len = RubyNumeric.fix2int(args[0]);
if (len < 0) {
throw getRuntime().newArgumentError("negative length " + len + " given");
} else if (len > 0) {
byte[] buffer = new byte[len];
int toRead = len;
int offset = 0;
int read = 0;
while (toRead > 0) {
read = io.read(buffer, offset, toRead);
if (read == -1) {
break;
}
toRead -= read;
offset += read;
} // hmm...
return RubyString.newString(getRuntime(), new ByteList(buffer, 0, len - toRead, false));
}
return RubyString.newEmptyString(getRuntime());
}
@JRubyMethod(name = "===", required = 1)
@Override
public IRubyObject op_eqq(ThreadContext context, IRubyObject other) {
return (RubyNumeric.fix2int(invokedynamic(context, this, OP_CMP, other)) == 0)
? getRuntime().getTrue()
: getRuntime().getFalse();
}
@JRubyMethod(optional = 1)
public IRubyObject shutdown(ThreadContext context, IRubyObject[] args) {
int how = 2;
if (args.length > 0) {
String howString = null;
if (args[0] instanceof RubyString) {
howString = ((RubyString) args[0]).asJavaString();
} else if (args[0] instanceof RubySymbol) {
howString = ((RubySymbol) args[0]).asJavaString();
}
if (howString != null) {
if (howString.equals("RD") || howString.equals("SHUT_RD")) {
how = 0;
} else if (howString.equals("WR") || howString.equals("SHUT_WR")) {
how = 1;
} else if (howString.equals("RDWR") || howString.equals("SHUT_RDWR")) {
how = 2;
}
} else {
how = RubyNumeric.fix2int(args[0]);
}
}
try {
return shutdownInternal(context, how);
} catch (BadDescriptorException e) {
throw context.runtime.newErrnoEBADFError();
}
}
private IRubyObject stepCommon19(ThreadContext context, IRubyObject step, Block block) {
Ruby runtime = context.getRuntime();
if (begin instanceof RubyFixnum && end instanceof RubyFixnum && step instanceof RubyFixnum) {
fixnumStep(context, runtime, ((RubyFixnum) step).getLongValue(), block);
} else if (begin instanceof RubyFloat
|| end instanceof RubyFloat
|| step instanceof RubyFloat) {
RubyNumeric.floatStep19(context, runtime, begin, end, step, isExclusive, block);
} else if (begin instanceof RubyNumeric
|| !checkIntegerType(runtime, begin, "to_int").isNil()
|| !checkIntegerType(runtime, end, "to_int").isNil()) {
numericStep19(context, runtime, step, block);
} else {
IRubyObject tmp = begin.checkStringType();
if (!tmp.isNil()) {
StepBlockCallBack callback = new StepBlockCallBack(block, RubyFixnum.one(runtime), step);
Block blockCallback =
CallBlock.newCallClosure(
this, runtime.getRange(), Arity.singleArgument(), callback, context);
((RubyString) tmp).uptoCommon19(context, end, isExclusive, blockCallback);
} else {
if (!begin.respondsTo("succ"))
throw runtime.newTypeError("can't iterate from " + begin.getMetaClass().getName());
// range_each_func(range, step_i, b, e, args);
rangeEach(context, new StepBlockCallBack(block, RubyFixnum.one(runtime), step));
}
}
return this;
}
private IRubyObject stepCommon(ThreadContext context, IRubyObject step, Block block) {
final Ruby runtime = context.getRuntime();
long unit = RubyNumeric.num2long(step);
if (unit < 0) throw runtime.newArgumentError("step can't be negative");
if (begin instanceof RubyFixnum && end instanceof RubyFixnum) {
if (unit == 0) throw runtime.newArgumentError("step can't be 0");
fixnumStep(context, runtime, unit, block);
} else {
IRubyObject tmp = begin.checkStringType();
if (!tmp.isNil()) {
if (unit == 0) throw runtime.newArgumentError("step can't be 0");
// rb_iterate((VALUE(*)_((VALUE)))str_step, (VALUE)args, step_i, (VALUE)iter);
StepBlockCallBack callback = new StepBlockCallBack(block, RubyFixnum.one(runtime), step);
Block blockCallback =
CallBlock.newCallClosure(
this, runtime.getRange(), Arity.singleArgument(), callback, context);
((RubyString) tmp).uptoCommon(context, end, isExclusive, blockCallback);
} else if (begin instanceof RubyNumeric) {
if (equalInternal(context, step, RubyFixnum.zero(runtime)))
throw runtime.newArgumentError("step can't be 0");
numericStep(context, runtime, step, block);
} else {
if (unit == 0) throw runtime.newArgumentError("step can't be 0");
if (!begin.respondsTo("succ"))
throw runtime.newTypeError("can't iterate from " + begin.getMetaClass().getName());
// range_each_func(range, step_i, b, e, args);
rangeEach(context, new StepBlockCallBack(block, RubyFixnum.one(runtime), step));
}
}
return this;
}
@JRubyMethod(name = "lineno=", required = 1)
@Override
public IRubyObject set_lineno(IRubyObject arg) {
data.lineno = RubyNumeric.fix2int(arg);
return getRuntime().getNil();
}
@JRubyMethod(name = "generate", meta = true)
public static IRubyObject generate(IRubyObject recv, IRubyObject arg) {
int keysize = RubyNumeric.fix2int(arg);
PKeyDSA dsa = new PKeyDSA(recv.getRuntime(), (RubyClass) recv);
dsaGenerate(dsa, keysize);
return dsa;
}
@JRubyMethod(name = "round", compat = CompatVersion.RUBY1_9)
public IRubyObject round19(ThreadContext context, IRubyObject arg) {
int ndigits = RubyNumeric.num2int(arg);
if (ndigits > 0) return RubyKernel.new_float(this, this);
if (ndigits == 0) return this;
Ruby runtime = context.runtime;
long bytes = (this instanceof RubyFixnum) ? 8 : RubyFixnum.fix2long(callMethod("size"));
/* If 10**N/2 > this, return 0 */
/* We have log_256(10) > 0.415241 and log_256(1/2)=-0.125 */
if (-0.415241 * ndigits - 0.125 > bytes) {
return RubyFixnum.zero(runtime);
}
IRubyObject f = Numeric.int_pow(context, 10, -ndigits);
if (this instanceof RubyFixnum && f instanceof RubyFixnum) {
long x = ((RubyFixnum) this).getLongValue();
long y = ((RubyFixnum) f).getLongValue();
boolean neg = x < 0;
if (neg) x = -x;
x = (x + y / 2) / y * y;
if (neg) x = -x;
return RubyFixnum.newFixnum(runtime, x);
} else if (f instanceof RubyFloat) {
return RubyFixnum.zero(runtime);
} else {
IRubyObject h = f.callMethod(context, "/", RubyFixnum.two(runtime));
IRubyObject r = callMethod(context, "%", f);
IRubyObject n = callMethod(context, "-", r);
String op = callMethod(context, "<", RubyFixnum.zero(runtime)).isTrue() ? "<=" : "<";
if (!r.callMethod(context, op, h).isTrue()) n = n.callMethod(context, "+", f);
return n;
}
}
/** 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);
}
/** match_aref */
@JRubyMethod(name = "[]")
public IRubyObject op_aref(IRubyObject idx, IRubyObject rest) {
if (!rest.isNil() || !(idx instanceof RubyFixnum) || ((RubyFixnum) idx).getLongValue() < 0) {
return ((RubyArray) to_a()).aref(idx, rest);
}
return RubyRegexp.nth_match(RubyNumeric.fix2int(idx), this);
}
// c: rand_int
private static IRubyObject randInt(
ThreadContext context, RandomType random, RubyInteger vmax, boolean restrictive) {
if (vmax instanceof RubyFixnum) {
long max = RubyNumeric.fix2long(vmax);
if (max == 0) {
return context.nil;
}
if (max < 0) {
if (restrictive) {
return context.nil;
}
max = -max;
}
return randLimitedFixnum(context, random, max - 1);
} else {
BigInteger big = vmax.getBigIntegerValue();
if (big.equals(BigInteger.ZERO)) {
return context.nil;
}
if (big.signum() < 0) {
if (restrictive) {
return context.nil;
}
big = big.abs();
}
big = big.subtract(BigInteger.ONE);
return randLimitedBignum(context, random, RubyBignum.newBignum(context.runtime, big));
}
}
@JRubyMethod(name = "round", compat = CompatVersion.RUBY1_9)
public IRubyObject round19(ThreadContext context, IRubyObject arg) {
int ndigits = RubyNumeric.num2int(arg);
if (ndigits > 0) return RubyKernel.new_float(this, this);
if (ndigits == 0) return this;
ndigits = -ndigits;
Ruby runtime = context.getRuntime();
if (ndigits < 0) throw runtime.newArgumentError("ndigits out of range");
IRubyObject f = Numeric.int_pow(context, 10, ndigits);
if (this instanceof RubyFixnum && f instanceof RubyFixnum) {
long x = ((RubyFixnum) this).getLongValue();
long y = ((RubyFixnum) f).getLongValue();
boolean neg = x < 0;
if (neg) x = -x;
x = (x + y / 2) / y * y;
if (neg) x = -x;
return RubyFixnum.newFixnum(runtime, x);
} else {
IRubyObject h = f.callMethod(context, "/", RubyFixnum.two(runtime));
IRubyObject r = callMethod(context, "%", f);
IRubyObject n = callMethod(context, "-", r);
if (!r.callMethod(context, "<", h).isTrue()) n = n.callMethod(context, "+", f);
return n;
}
}
@JRubyMethod(name = "+", required = 1, compat = CompatVersion.RUBY1_8)
public IRubyObject op_plus(IRubyObject other) {
if (other instanceof RubyTime) {
throw getRuntime().newTypeError("time + time ?");
}
long adjustment = Math.round(RubyNumeric.num2dbl(other) * 1000000);
return opPlusCommon(adjustment);
}
@JRubyMethod(name = "pos=", required = 1)
public IRubyObject set_pos(IRubyObject arg) {
pos = RubyNumeric.fix2int(arg);
if (pos < 0) {
throw getRuntime().newErrnoEINVALError("Invalid argument");
}
return getRuntime().getNil();
}
@JRubyMethod(name = "deflate", required = 1, optional = 1)
public IRubyObject deflate(IRubyObject[] args) throws Exception {
args = Arity.scanArgs(getRuntime(), args, 1, 1);
int flush = 0; // NO_FLUSH
if (!args[1].isNil()) {
flush = RubyNumeric.fix2int(args[1]);
}
return defl.deflate(args[0].convertToString().getByteList(), flush);
}
@JRubyMethod(name = "deflate", required = 1, optional = 1, meta = true)
public static IRubyObject s_deflate(IRubyObject recv, IRubyObject[] args) throws Exception {
args = Arity.scanArgs(recv.getRuntime(), args, 1, 1);
int level = -1;
if (!args[1].isNil()) {
level = RubyNumeric.fix2int(args[1]);
}
return ZlibDeflate.s_deflate(recv, args[0].convertToString().getByteList(), level);
}
protected static SocketLevel levelFromArg(IRubyObject _level) {
SocketLevel level;
if (_level instanceof RubyString || _level instanceof RubySymbol) {
level = SocketLevel.valueOf("SOL_" + _level.toString());
} else {
level = SocketLevel.valueOf(RubyNumeric.fix2int(_level));
}
return level;
}
@JRubyMethod(name = "flush", optional = 1)
public IRubyObject flush(IRubyObject[] args) throws IOException {
if (args.length == 0
|| args[0].isNil()
|| RubyNumeric.fix2int(args[0]) != 0) { // Zlib::NO_FLUSH
io.flush();
}
return getRuntime().getNil();
}
protected static SocketOption optionFromArg(IRubyObject _opt) {
SocketOption opt;
if (_opt instanceof RubyString || _opt instanceof RubySymbol) {
opt = SocketOption.valueOf("SO_" + _opt.toString());
} else {
opt = SocketOption.valueOf(RubyNumeric.fix2int(_opt));
}
return opt;
}
protected boolean asBoolean(IRubyObject val) {
if (val instanceof RubyString) {
return stringAsNumber(val) != 0;
} else if (val instanceof RubyNumeric) {
return RubyNumeric.fix2int(val) != 0;
} else {
return val.isTrue();
}
}
private int asNumber(IRubyObject val) {
if (val instanceof RubyNumeric) {
return RubyNumeric.fix2int(val);
} else if (val instanceof RubyBoolean) {
return val.isTrue() ? 1 : 0;
} else {
return stringAsNumber(val);
}
}
private int stringAsNumber(IRubyObject val) {
ByteList str = val.convertToString().getByteList();
IRubyObject res = Pack.unpack(getRuntime(), str, FORMAT_SMALL_I).entry(0);
if (res.isNil()) {
throw getRuntime().newErrnoEINVALError();
}
return RubyNumeric.fix2int(res);
}
@JRubyMethod
public IRubyObject recv(ThreadContext context, IRubyObject _length) {
Ruby runtime = context.runtime;
ByteList bytes = doReceive(context, RubyNumeric.fix2int(_length));
if (bytes == null) return context.nil;
return RubyString.newString(runtime, bytes);
}
