/** match_post_match */
@JRubyMethod(name = "post_match")
public IRubyObject post_match(ThreadContext context) {
check();
if (begin == -1) return context.getRuntime().getNil();
return makeShared(context.getRuntime(), str, end, str.getByteList().length() - end)
.infectBy(this);
}
@Override
public Object interpret(
ThreadContext context,
DynamicScope currDynScope,
IRubyObject self,
Object[] temp,
Block block) {
// SSS FIXME: This is ugly and needs fixing. Is there another way of capturing this info?
RubyModule containerModule =
(candidateScope == null) ? null : candidateScope.getStaticScope().getModule();
if (containerModule == null)
containerModule = ASTInterpreter.getClassVariableBase(context, context.getRuntime());
if (containerModule == null && object != null) {
IRubyObject arg = (IRubyObject) object.retrieve(context, self, currDynScope, temp);
// SSS: What is the right thing to do here?
containerModule =
arg
.getMetaClass(); // (arg instanceof RubyClass) ? ((RubyClass)arg).getRealClass() :
// arg.getType();
}
if (containerModule == null)
throw context.getRuntime().newTypeError("no class/module to define class variable");
return containerModule;
}
@JRubyMethod(
name = {"call", "[]", "yield"},
rest = true,
frame = true,
compat = CompatVersion.RUBY1_9)
public IRubyObject call19(ThreadContext context, IRubyObject[] args, Block block) {
if (isLambda()) {
this.block.arity().checkArity(context.getRuntime(), args.length);
}
if (isProc()) {
List<IRubyObject> list = new ArrayList<IRubyObject>(Arrays.asList(args));
int required = this.block.arity().required();
if (this.block.arity().isFixed()) {
if (required > args.length) {
for (int i = args.length; i < required; i++) {
list.add(context.getRuntime().getNil());
}
args = list.toArray(args);
} else if (required < args.length) {
args = list.subList(0, required).toArray(args);
}
}
}
return call(context, args, null, block);
}
@JRubyMethod(required = 4)
public IRubyObject initialize(ThreadContext context, IRubyObject[] args) {
if (!(args[2] instanceof MappedType)) {
throw context
.getRuntime()
.newTypeError(
args[2],
context
.getRuntime()
.fastGetModule("FFI")
.fastGetClass("Type")
.fastGetClass("Mapped"));
}
if (!(args[3] instanceof Field)) {
throw context
.getRuntime()
.newTypeError(
args[3],
context
.getRuntime()
.fastGetModule("FFI")
.fastGetClass("StructLayout")
.fastGetClass("Field"));
}
init(
args[0],
args[2],
args[1],
new MappedFieldIO((MappedType) args[2], ((Field) args[3]).getFieldIO()));
return this;
}
@JRubyMethod(
name = {"create_invoker", "createInvoker"},
required = 5)
public IRubyObject createInvoker(ThreadContext context, IRubyObject[] args) {
RubyArray paramTypes = (RubyArray) args[3];
NativeParam[] nativeParamTypes = new NativeParam[paramTypes.size()];
for (int i = 0; i < paramTypes.size(); ++i) {
IRubyObject obj = (IRubyObject) paramTypes.entry(i);
if (obj instanceof NativeParam) {
nativeParamTypes[i] = (NativeParam) obj;
} else if (obj instanceof RubyInteger) {
nativeParamTypes[i] = NativeType.valueOf(Util.int32Value(obj));
} else {
context.getRuntime().newArgumentError("Invalid parameter type");
}
}
try {
return createInvoker(
context.getRuntime(),
args[0].isNil() ? null : args[0].toString(),
args[1].toString(),
NativeType.valueOf(Util.int32Value(args[2])),
nativeParamTypes,
args[4].toString());
} catch (UnsatisfiedLinkError ex) {
return context.getRuntime().getNil();
}
}
public final void marshal(
ThreadContext context, InvocationBuffer buffer, IRubyObject parameter) {
if (!(parameter instanceof Struct)) {
throw context
.getRuntime()
.newTypeError(
"wrong argument type "
+ parameter.getMetaClass().getName()
+ " (expected instance of FFI::Struct)");
}
IRubyObject memory = ((Struct) parameter).getMemory();
if (!(memory instanceof AbstractMemory)) {
throw context
.getRuntime()
.newTypeError("wrong struct memory type " + memory.getMetaClass().getName());
}
MemoryIO io = ((AbstractMemory) memory).getMemoryIO();
if (io instanceof DirectMemoryIO) {
if (io.isNull()) {
throw context
.getRuntime()
.newRuntimeError("Cannot use a NULL pointer as a struct by value argument");
}
buffer.putStruct(((DirectMemoryIO) io).getAddress());
} else if (io instanceof ArrayMemoryIO) {
ArrayMemoryIO aio = (ArrayMemoryIO) io;
buffer.putStruct(aio.array(), aio.arrayOffset());
} else {
throw context.getRuntime().newRuntimeError("Invalid struct memory");
}
}
@JRubyMethod(name = "root=")
public IRubyObject root_set(ThreadContext context, IRubyObject newRoot_) {
// in case of document fragment, temporary root node should be deleted.
// Java can't have a root whose value is null. Instead of setting null,
// the method sets user data so that other methods are able to know the root
// should be nil.
if (newRoot_ instanceof RubyNil) {
getDocument().getDocumentElement().setUserData(NokogiriHelpers.VALID_ROOT_NODE, false, null);
return newRoot_;
}
XmlNode newRoot = asXmlNode(context, newRoot_);
IRubyObject root = root(context);
if (root.isNil()) {
Node newRootNode;
if (getDocument() == newRoot.getOwnerDocument()) {
newRootNode = newRoot.node;
} else {
// must copy otherwise newRoot may exist in two places
// with different owner document.
newRootNode = getDocument().importNode(newRoot.node, true);
}
add_child_node(context, getCachedNodeOrCreate(context.getRuntime(), newRootNode));
} else {
Node rootNode = asXmlNode(context, root).node;
((XmlNode) getCachedNodeOrCreate(context.getRuntime(), rootNode))
.replace_node(context, newRoot);
}
return newRoot;
}
public void put(
ThreadContext context,
StructLayout.Storage cache,
Member m,
IRubyObject ptr,
IRubyObject value) {
if (value instanceof Pointer) {
m.getMemoryIO(ptr).putMemoryIO(m.offset, ((Pointer) value).getMemoryIO());
} else if (value instanceof Struct) {
MemoryIO mem = ((Struct) value).getMemoryIO();
if (!(mem instanceof DirectMemoryIO)) {
throw context
.getRuntime()
.newArgumentError("Struct memory not backed by a native pointer");
}
m.getMemoryIO(ptr).putMemoryIO(m.offset, mem);
} else if (value instanceof RubyInteger) {
m.getMemoryIO(ptr).putAddress(m.offset, Util.int64Value(ptr));
} else if (value.respondsTo("to_ptr")) {
IRubyObject addr = value.callMethod(context, "to_ptr");
if (addr instanceof Pointer) {
m.getMemoryIO(ptr).putMemoryIO(m.offset, ((Pointer) addr).getMemoryIO());
} else {
throw context.getRuntime().newArgumentError("Invalid pointer value");
}
} else if (value.isNil()) {
m.getMemoryIO(ptr).putAddress(m.offset, 0L);
} else {
throw context.getRuntime().newArgumentError("Invalid pointer value");
}
cache.putReference(m, value);
}
@JRubyMethod(name = {"getpeername", "__getpeername"})
public IRubyObject getpeername(ThreadContext context) {
SocketAddress sock = getRemoteSocket();
if (null == sock) {
throw context.getRuntime().newIOError("Not Supported");
}
return context.getRuntime().newString(sock.toString());
}
public final IRubyObject invoke(
ThreadContext context, Function function, HeapInvocationBuffer args) {
final long address = invoker.invokeAddress(function, args);
return RubyArray.newArray(
context.getRuntime(),
FFIUtil.getString(context.getRuntime(), address),
new Pointer(context.getRuntime(), NativeMemoryIO.wrap(context.getRuntime(), address)));
}
@JRubyMethod(name = "<=>", required = 1)
public IRubyObject op_cmp(ThreadContext context, IRubyObject other) {
if (other instanceof RubyTime) {
return context.getRuntime().newFixnum(cmp((RubyTime) other));
}
return context.getRuntime().getNil();
}
/** int_succ */
@JRubyMethod(name = {"succ", "next"})
public IRubyObject succ(ThreadContext context) {
if (this instanceof RubyFixnum) {
return RubyFixnum.newFixnum(context.getRuntime(), getLongValue() + 1L);
} else {
return callMethod(context, "+", RubyFixnum.one(context.getRuntime()));
}
}
public static IRubyObject retryJumpError(ThreadContext context) {
throw context
.getRuntime()
.newLocalJumpError(
RubyLocalJumpError.Reason.RETRY,
context.getRuntime().getNil(),
"retry outside of rescue not supported");
}
@JRubyMethod(name = {"size", "length"})
public IRubyObject size(ThreadContext context) {
if (!isClosed()) {
flush();
return context.getRuntime().newFileStat(path, false).size();
}
return RubyFixnum.zero(context.getRuntime());
}
public IRubyObject get(
ThreadContext context, StructLayout.Storage cache, Member m, IRubyObject ptr) {
MemoryIO io = m.getMemoryIO(ptr).getMemoryIO(m.getOffset(ptr));
if (io == null || io.isNull()) {
return context.getRuntime().getNil();
}
return RubyString.newStringNoCopy(context.getRuntime(), io.getZeroTerminatedByteArray(0));
}
@JRubyMethod(meta = true)
public static IRubyObject decode(ThreadContext ctx, IRubyObject recv, IRubyObject data) {
try {
byte[] bytes = data.convertToString().getBytes();
byte[] decoded = Hex.decode(bytes);
return ctx.getRuntime().newString(new ByteList(decoded, false));
} catch (RuntimeException ex) {
throw Errors.newHexError(ctx.getRuntime(), ex.getMessage());
}
}
/** Needed for Enumerable implementation */
@JRubyMethod(name = "each")
public IRubyObject each(ThreadContext context, Block block) {
if (!block.isGiven()) {
throw context.getRuntime().newLocalJumpErrorNoBlock();
}
for (int i = 0; i < arrayType.length(); ++i) {
block.yield(context, get(context.getRuntime(), i));
}
return this;
}
@Override
public IRubyObject get(ThreadContext context, IRubyObject rbkey) {
String key = rubyStringToString(rbkey);
Element element = (Element) node;
String value = element.getAttribute(key);
if (!value.equals("")) {
return context.getRuntime().newString(value);
}
return context.getRuntime().getNil();
}
private static IRubyObject jacobToRuby(ThreadContext context, Variant value) {
if (value == null || value.isNull()) return context.getRuntime().getNil();
Object object = value.toJavaObject();
if (object instanceof Dispatch)
return new WIN32OLE(
context.getRuntime(), context.getRuntime().getClass("WIN32OLE"), (Dispatch) object);
else if (object instanceof SafeArray) return safeArrayToRubyArray(context, (SafeArray) object);
return JavaUtil.convertJavaToRuby(context.getRuntime(), object);
}
private void checkOpCoercion(ThreadContext context, IRubyObject other) {
if (other instanceof RubyString) {
throw context.getRuntime().newTypeError("no implicit conversion to rational from string");
} else if (other.isNil()) {
throw context.getRuntime().newTypeError("no implicit conversion to rational from nil");
} else if (!other.respondsTo("to_r")) {
throw context
.getRuntime()
.newTypeError("can't convert " + other.getMetaClass().getBaseName() + " into Rational");
}
}
void call(ThreadContext context, IRubyObject arg) {
if (iter instanceof RubyFixnum) {
iter = RubyFixnum.newFixnum(context.getRuntime(), ((RubyFixnum) iter).getLongValue() - 1);
} else {
iter = iter.callMethod(context, "-", RubyFixnum.one(context.getRuntime()));
}
if (iter == RubyFixnum.zero(context.getRuntime())) {
block.yield(context, arg);
iter = step;
}
}
private static Buffer allocate(
ThreadContext context, IRubyObject recv, IRubyObject sizeArg, int count, int flags) {
final int typeSize = calculateSize(context, sizeArg);
final int total = typeSize * count;
return new Buffer(
context.getRuntime(),
recv,
new ArrayMemoryIO(context.getRuntime(), total),
total,
typeSize,
flags);
}
@Override
@JRubyMethod(visibility = Visibility.PRIVATE)
public IRubyObject get(ThreadContext context, IRubyObject rbkey) {
if (rbkey == null || rbkey.isNil()) context.getRuntime().getNil();
String key = rubyStringToString(rbkey);
Element element = (Element) node;
String value = element.getAttribute(key);
if (!value.equals("")) {
return context.getRuntime().newString(value);
}
return context.getRuntime().getNil();
}
@JRubyMethod
public IRubyObject encoding(ThreadContext context) {
if (this.encoding == null) {
if (getDocument().getXmlEncoding() == null) {
this.encoding = context.getRuntime().getNil();
} else {
this.encoding = context.getRuntime().newString(getDocument().getXmlEncoding());
}
}
return this.encoding;
}
@JRubyMethod(optional = 1)
public IRubyObject shutdown(ThreadContext context, IRubyObject[] args) {
if (context.getRuntime().getSafeLevel() >= 4 && tainted_p(context).isFalse()) {
throw context.getRuntime().newSecurityError("Insecure: can't shutdown socket");
}
int how = 2;
if (args.length > 0) {
how = RubyNumeric.fix2int(args[0]);
}
return shutdownInternal(context, how);
}
public IRubyObject getInternalSubset(ThreadContext context) {
IRubyObject dtd = (IRubyObject) node.getUserData(DTD_INTERNAL_SUBSET);
if (dtd == null) {
if (getDocument().getDoctype() == null) dtd = context.getRuntime().getNil();
else dtd = XmlDtd.newFromInternalSubset(context.getRuntime(), getDocument());
setInternalSubset(dtd);
}
return dtd;
}
// Look through all mappings to find a match entry for this field
private static void installField(
ThreadContext context,
Map<String, String> fieldMap,
Field field,
RubyModule module,
boolean asReader,
boolean asWriter) {
boolean isFinal = Modifier.isFinal(field.getModifiers());
for (Iterator<Map.Entry<String, String>> iter = fieldMap.entrySet().iterator();
iter.hasNext(); ) {
Map.Entry<String, String> entry = iter.next();
String key = entry.getKey();
if (key.equals(field.getName())) {
if (Ruby.isSecurityRestricted() && !Modifier.isPublic(field.getModifiers())) {
throw context
.getRuntime()
.newSecurityError(
"Cannot change accessibility on fields in a restricted mode: field '"
+ field.getName()
+ "'");
}
String asName = entry.getValue();
if (Modifier.isStatic(field.getModifiers())) {
if (asReader)
module.getSingletonClass().addMethod(asName, new StaticFieldGetter(key, module, field));
if (asWriter) {
if (isFinal)
throw context
.getRuntime()
.newSecurityError("Cannot change final field '" + field.getName() + "'");
module
.getSingletonClass()
.addMethod(asName + "=", new StaticFieldSetter(key, module, field));
}
} else {
if (asReader) module.addMethod(asName, new InstanceFieldGetter(key, module, field));
if (asWriter) {
if (isFinal)
throw context
.getRuntime()
.newSecurityError("Cannot change final field '" + field.getName() + "'");
module.addMethod(asName + "=", new InstanceFieldSetter(key, module, field));
}
}
iter.remove();
break;
}
}
}
@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
public IRubyObject root(ThreadContext context) {
Node rootNode = getDocument().getDocumentElement();
try {
Boolean isValid = (Boolean) rootNode.getUserData(NokogiriHelpers.VALID_ROOT_NODE);
if (!isValid) return context.getRuntime().getNil();
} catch (NullPointerException e) {
// does nothing since nil wasn't set to the root node before.
}
if (rootNode == null) return context.getRuntime().getNil();
else return getCachedNodeOrCreate(context.getRuntime(), rootNode);
}
public final void marshal(
ThreadContext context, InvocationBuffer buffer, IRubyObject parameter) {
if (parameter instanceof RubyString) {
Util.checkStringSafety(context.getRuntime(), parameter);
ByteList bl = ((RubyString) parameter).getByteList();
buffer.putArray(
bl.unsafeBytes(), bl.begin(), bl.length(), ArrayFlags.IN | ArrayFlags.NULTERMINATE);
} else if (parameter.isNil()) {
buffer.putAddress(0);
} else {
throw context.getRuntime().newArgumentError("Invalid string parameter");
}
}
