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; }