primitiveAtPut(void)
{
// FloatArrayPlugin>>#primitiveAtPut
float *floatPtr;
double floatValue;
sqInt index;
sqInt rcvr;
sqInt value;
value = stackValue(0);
if (isIntegerObject(value)) {
floatValue = ((double) (integerValueOf(value)) );
}
else {
floatValue = floatValueOf(value);
}
index = stackIntegerValue(1);
rcvr = stackObjectValue(2);
if (failed()) {
return null;
}
success(isWords(rcvr));
success((index > 0)
&& (index <= (slotSizeOf(rcvr))));
if (failed()) {
return null;
}
floatPtr = firstIndexableField(rcvr);
floatPtr[index - 1] = (((float) floatValue));
if (!(failed())) {
popthenPush(3, value);
}
}
primitiveAtPut(void)
{
float *floatPtr;
double floatValue;
sqInt index;
sqInt rcvr;
sqInt value;
value = stackValue(0);
if (isIntegerObject(value)) {
floatValue = ((double) (integerValueOf(value)) );
}
else {
floatValue = floatValueOf(value);
}
index = stackIntegerValue(1);
rcvr = stackValue(2);
if (!((!(failed()))
&& ((isWords(rcvr))
&& ((index > 0)
&& (index <= (slotSizeOf(rcvr))))))) {
return primitiveFail();
}
floatPtr = firstIndexableField(rcvr);
floatPtr[index - 1] = (((float) floatValue));
popthenPush(3, value);
return 0;
}
/* Matrix2x3Plugin>>#loadArgumentPoint: */
static sqInt
loadArgumentPoint(sqInt point)
{
int isInt;
sqInt oop;
if (failed()) {
return null;
}
if (!((fetchClassOf(point)) == (classPoint()))) {
return primitiveFail();
}
oop = fetchPointerofObject(0, point);
isInt = isIntegerObject(oop);
if (!(isInt
|| (isFloatObject(oop)))) {
return primitiveFail();
}
if (isInt) {
m23ArgX = integerValueOf(oop);
}
else {
m23ArgX = floatValueOf(oop);
}
oop = fetchPointerofObject(1, point);
isInt = isIntegerObject(oop);
if (!(isInt
|| (isFloatObject(oop)))) {
return primitiveFail();
}
if (isInt) {
m23ArgY = integerValueOf(oop);
}
else {
m23ArgY = floatValueOf(oop);
}
return 0;
}
// Entry point from the normal count down mechanism - not used from GC as that queues many objects
// which could generate a large number of async. signals to the same semaphore
void ObjectMemory::finalize(OTE* ote)
{
#if defined(_DEBUG)
{
if (abs(Interpreter::executionTrace) > 1)
{
tracelock lock(TRACESTREAM);
TRACESTREAM << "Finalizing " << ote << "\n";
}
}
#endif
MemoryManager* memMan = memoryManager();
Interpreter::queueForFinalization(ote, (unsigned)integerValueOf(memMan->m_hospiceHighWater));
}
void Interpreter::scheduleFinalization()
{
// Signal the bereavement semaphore first, since it belongs to a very high priority
// process, and we'll only need to do more work switching to it if we signal it
// after the finalize semaphore
//MemoryManager& memMan = memoryManager();
if (!m_qBereavements.isEmpty())
{
SemaphoreOTE* bereavementsSemaphore = Pointers.BereavementSemaphore; // memMan.m_bereavements;
if (!bereavementsSemaphore->isNil())
{
#ifdef _DEBUG
{
tracelock lock(TRACESTREAM);
TRACESTREAM << "Signalling undertaker process" << endl;
}
#endif
asynchronousSignal(bereavementsSemaphore );
}
}
if (!m_qForFinalize.isEmpty())
{
SemaphoreOTE* finalizationSemaphore = Pointers.FinalizeSemaphore; //memMan.m_lastRequests;
if (!finalizationSemaphore->isNil())
{
#ifdef _DEBUG
{
tracelock lock(TRACESTREAM);
TRACESTREAM << "Signalling finalizer process" << endl;
}
#endif
asynchronousSignal(finalizationSemaphore);
}
}
MemoryManager* memMan = ObjectMemory::memoryManager();
unsigned count = m_qForFinalize.Count();
// Raise interrupt when at or above high water mark
if (count >= (unsigned)integerValueOf(memMan->m_hospiceHighWater))
queueInterrupt(VMI_HOSPICECRISIS, integerObjectOf(count));
}
static void setIntegerField(JNIEnv* env, jobject obj, const char* fieldName, int value) {
ScopedLocalRef<jobject> integerValue(env, integerValueOf(env, value));
jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "Ljava/lang/Integer;");
env->SetObjectField(obj, fid, integerValue.get());
}
static jobject OSNetworkSystem_getSocketOption(JNIEnv* env, jobject, jobject fileDescriptor, jint option) {
NetFd fd(env, fileDescriptor);
if (fd.isClosed()) {
return NULL;
}
int family = getSocketAddressFamily(fd.get());
if (family != AF_INET && family != AF_INET6) {
jniThrowSocketException(env, EAFNOSUPPORT);
return NULL;
}
switch (option) {
case JAVASOCKOPT_TCP_NODELAY:
return getSocketOption_Boolean(env, fd, IPPROTO_TCP, TCP_NODELAY);
case JAVASOCKOPT_SO_SNDBUF:
return getSocketOption_Integer(env, fd, SOL_SOCKET, SO_SNDBUF);
case JAVASOCKOPT_SO_RCVBUF:
return getSocketOption_Integer(env, fd, SOL_SOCKET, SO_RCVBUF);
case JAVASOCKOPT_SO_BROADCAST:
return getSocketOption_Boolean(env, fd, SOL_SOCKET, SO_BROADCAST);
case JAVASOCKOPT_SO_REUSEADDR:
return getSocketOption_Boolean(env, fd, SOL_SOCKET, SO_REUSEADDR);
case JAVASOCKOPT_SO_KEEPALIVE:
return getSocketOption_Boolean(env, fd, SOL_SOCKET, SO_KEEPALIVE);
case JAVASOCKOPT_SO_OOBINLINE:
return getSocketOption_Boolean(env, fd, SOL_SOCKET, SO_OOBINLINE);
case JAVASOCKOPT_IP_TOS:
if (family == AF_INET) {
return getSocketOption_Integer(env, fd, IPPROTO_IP, IP_TOS);
} else {
return getSocketOption_Integer(env, fd, IPPROTO_IPV6, IPV6_TCLASS);
}
case JAVASOCKOPT_SO_LINGER:
{
linger lingr;
bool ok = getSocketOption(env, fd, SOL_SOCKET, SO_LINGER, &lingr);
if (!ok) {
return NULL; // We already threw.
} else if (!lingr.l_onoff) {
return booleanValueOf(env, false);
} else {
return integerValueOf(env, lingr.l_linger);
}
}
case JAVASOCKOPT_SO_TIMEOUT:
{
timeval timeout;
bool ok = getSocketOption(env, fd, SOL_SOCKET, SO_RCVTIMEO, &timeout);
return ok ? integerValueOf(env, toMs(timeout)) : NULL;
}
#ifdef ENABLE_MULTICAST
case JAVASOCKOPT_IP_MULTICAST_IF:
{
// Although setsockopt(2) can take an ip_mreqn for IP_MULTICAST_IF, getsockopt(2)
// always returns an in_addr.
sockaddr_storage ss;
memset(&ss, 0, sizeof(ss));
ss.ss_family = AF_INET; // This call is IPv4-only.
sockaddr_in* sa = reinterpret_cast<sockaddr_in*>(&ss);
if (!getSocketOption(env, fd, IPPROTO_IP, IP_MULTICAST_IF, &sa->sin_addr)) {
return NULL;
}
return socketAddressToInetAddress(env, &ss);
}
case JAVASOCKOPT_IP_MULTICAST_IF2:
if (family == AF_INET) {
// The caller's asking for an interface index, but that's not how IPv4 works.
// Our Java should never get here, because we'll try IP_MULTICAST_IF first and
// that will satisfy us.
jniThrowSocketException(env, EAFNOSUPPORT);
} else {
return getSocketOption_Integer(env, fd, IPPROTO_IPV6, IPV6_MULTICAST_IF);
}
case JAVASOCKOPT_IP_MULTICAST_LOOP:
if (family == AF_INET) {
// Although IPv6 was cleaned up to use int, IPv4 multicast loopback uses a byte.
u_char loopback;
bool ok = getSocketOption(env, fd, IPPROTO_IP, IP_MULTICAST_LOOP, &loopback);
return ok ? booleanValueOf(env, loopback) : NULL;
} else {
return getSocketOption_Boolean(env, fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP);
}
case JAVASOCKOPT_MULTICAST_TTL:
if (family == AF_INET) {
// Although IPv6 was cleaned up to use int, and IPv4 non-multicast TTL uses int,
// IPv4 multicast TTL uses a byte.
u_char ttl;
bool ok = getSocketOption(env, fd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl);
return ok ? integerValueOf(env, ttl) : NULL;
} else {
return getSocketOption_Integer(env, fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS);
}
#else
case JAVASOCKOPT_MULTICAST_TTL:
case JAVASOCKOPT_IP_MULTICAST_IF:
case JAVASOCKOPT_IP_MULTICAST_IF2:
case JAVASOCKOPT_IP_MULTICAST_LOOP:
jniThrowException(env, "java/lang/UnsupportedOperationException", NULL);
return NULL;
#endif // def ENABLE_MULTICAST
default:
jniThrowSocketException(env, ENOPROTOOPT);
return NULL;
}
}
static jobject getSocketOption_Integer(JNIEnv* env, const NetFd& fd, int level, int option) {
int value;
return getSocketOption(env, fd, level, option, &value) ? integerValueOf(env, value) : NULL;
}
