/*
|
* Copyright (c) 1998, 2005, Oracle and/or its affiliates. All rights reserved.
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
*
|
* This code is free software; you can redistribute it and/or modify it
|
* under the terms of the GNU General Public License version 2 only, as
|
* published by the Free Software Foundation. Oracle designates this
|
* particular file as subject to the "Classpath" exception as provided
|
* by Oracle in the LICENSE file that accompanied this code.
|
*
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
* version 2 for more details (a copy is included in the LICENSE file that
|
* accompanied this code).
|
*
|
* You should have received a copy of the GNU General Public License version
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
*
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
* or visit www.oracle.com if you need additional information or have any
|
* questions.
|
*/
|
|
#include "util.h"
|
#include "ArrayReferenceImpl.h"
|
#include "inStream.h"
|
#include "outStream.h"
|
|
static jboolean
|
length(PacketInputStream *in, PacketOutputStream *out)
|
{
|
JNIEnv *env = getEnv();
|
jsize arrayLength;
|
|
jarray array = inStream_readArrayRef(env, in);
|
if (inStream_error(in)) {
|
return JNI_TRUE;
|
}
|
|
arrayLength = JNI_FUNC_PTR(env,GetArrayLength)(env, array);
|
(void)outStream_writeInt(out, arrayLength);
|
return JNI_TRUE;
|
}
|
|
static void *
|
newComponents(PacketOutputStream *out, jint length, size_t nbytes)
|
{
|
void *ptr = NULL;
|
|
if ( length > 0 ) {
|
ptr = jvmtiAllocate(length*((jint)nbytes));
|
if ( ptr == NULL ) {
|
outStream_setError(out, JDWP_ERROR(OUT_OF_MEMORY));
|
} else {
|
(void)memset(ptr, 0, length*nbytes);
|
}
|
}
|
return ptr;
|
}
|
|
static void
|
deleteComponents(void *ptr)
|
{
|
jvmtiDeallocate(ptr);
|
}
|
|
static void
|
writeBooleanComponents(JNIEnv *env, PacketOutputStream *out,
|
jarray array, jint index, jint length)
|
{
|
jboolean *components;
|
|
components = newComponents(out, length, sizeof(jboolean));
|
if (components != NULL) {
|
jint i;
|
JNI_FUNC_PTR(env,GetBooleanArrayRegion)(env, array, index, length, components);
|
for (i = 0; i < length; i++) {
|
(void)outStream_writeBoolean(out, components[i]);
|
}
|
deleteComponents(components);
|
}
|
}
|
|
static void
|
writeByteComponents(JNIEnv *env, PacketOutputStream *out,
|
jarray array, jint index, jint length)
|
{
|
jbyte *components;
|
|
components = newComponents(out, length, sizeof(jbyte));
|
if (components != NULL) {
|
jint i;
|
JNI_FUNC_PTR(env,GetByteArrayRegion)(env, array, index, length, components);
|
for (i = 0; i < length; i++) {
|
(void)outStream_writeByte(out, components[i]);
|
}
|
deleteComponents(components);
|
}
|
}
|
|
static void
|
writeCharComponents(JNIEnv *env, PacketOutputStream *out,
|
jarray array, jint index, jint length)
|
{
|
jchar *components;
|
|
components = newComponents(out, length, sizeof(jchar));
|
if (components != NULL) {
|
jint i;
|
JNI_FUNC_PTR(env,GetCharArrayRegion)(env, array, index, length, components);
|
for (i = 0; i < length; i++) {
|
(void)outStream_writeChar(out, components[i]);
|
}
|
deleteComponents(components);
|
}
|
}
|
|
static void
|
writeShortComponents(JNIEnv *env, PacketOutputStream *out,
|
jarray array, jint index, jint length)
|
{
|
jshort *components;
|
|
components = newComponents(out, length, sizeof(jshort));
|
if (components != NULL) {
|
jint i;
|
JNI_FUNC_PTR(env,GetShortArrayRegion)(env, array, index, length, components);
|
for (i = 0; i < length; i++) {
|
(void)outStream_writeShort(out, components[i]);
|
}
|
deleteComponents(components);
|
}
|
}
|
|
static void
|
writeIntComponents(JNIEnv *env, PacketOutputStream *out,
|
jarray array, jint index, jint length)
|
{
|
jint *components;
|
|
components = newComponents(out, length, sizeof(jint));
|
if (components != NULL) {
|
jint i;
|
JNI_FUNC_PTR(env,GetIntArrayRegion)(env, array, index, length, components);
|
for (i = 0; i < length; i++) {
|
(void)outStream_writeInt(out, components[i]);
|
}
|
deleteComponents(components);
|
}
|
}
|
|
static void
|
writeLongComponents(JNIEnv *env, PacketOutputStream *out,
|
jarray array, jint index, jint length)
|
{
|
jlong *components;
|
|
components = newComponents(out, length, sizeof(jlong));
|
if (components != NULL) {
|
jint i;
|
JNI_FUNC_PTR(env,GetLongArrayRegion)(env, array, index, length, components);
|
for (i = 0; i < length; i++) {
|
(void)outStream_writeLong(out, components[i]);
|
}
|
deleteComponents(components);
|
}
|
}
|
|
static void
|
writeFloatComponents(JNIEnv *env, PacketOutputStream *out,
|
jarray array, jint index, jint length)
|
{
|
jfloat *components;
|
|
components = newComponents(out, length, sizeof(jfloat));
|
if (components != NULL) {
|
jint i;
|
JNI_FUNC_PTR(env,GetFloatArrayRegion)(env, array, index, length, components);
|
for (i = 0; i < length; i++) {
|
(void)outStream_writeFloat(out, components[i]);
|
}
|
deleteComponents(components);
|
}
|
}
|
|
static void
|
writeDoubleComponents(JNIEnv *env, PacketOutputStream *out,
|
jarray array, jint index, jint length)
|
{
|
jdouble *components;
|
|
components = newComponents(out, length, sizeof(jdouble));
|
if (components != NULL) {
|
jint i;
|
JNI_FUNC_PTR(env,GetDoubleArrayRegion)(env, array, index, length, components);
|
for (i = 0; i < length; i++) {
|
(void)outStream_writeDouble(out, components[i]);
|
}
|
deleteComponents(components);
|
}
|
}
|
|
static void
|
writeObjectComponents(JNIEnv *env, PacketOutputStream *out,
|
jarray array, jint index, jint length)
|
{
|
|
WITH_LOCAL_REFS(env, length) {
|
|
int i;
|
jobject component;
|
|
for (i = 0; i < length; i++) {
|
component = JNI_FUNC_PTR(env,GetObjectArrayElement)(env, array, index + i);
|
if (JNI_FUNC_PTR(env,ExceptionOccurred)(env)) {
|
/* cleared by caller */
|
break;
|
}
|
(void)outStream_writeByte(out, specificTypeKey(env, component));
|
(void)outStream_writeObjectRef(env, out, component);
|
}
|
|
} END_WITH_LOCAL_REFS(env);
|
}
|
|
static jboolean
|
getValues(PacketInputStream *in, PacketOutputStream *out)
|
{
|
JNIEnv *env = getEnv();
|
jint arrayLength;
|
jarray array;
|
jint index;
|
jint length;
|
|
array = inStream_readArrayRef(env, in);
|
if (inStream_error(in)) {
|
return JNI_TRUE;
|
}
|
index = inStream_readInt(in);
|
if (inStream_error(in)) {
|
return JNI_TRUE;
|
}
|
length = inStream_readInt(in);
|
if (inStream_error(in)) {
|
return JNI_TRUE;
|
}
|
|
arrayLength = JNI_FUNC_PTR(env,GetArrayLength)(env, array);
|
|
if (length == -1) {
|
length = arrayLength - index;
|
}
|
|
if ((index < 0) || (index > arrayLength - 1)) {
|
outStream_setError(out, JDWP_ERROR(INVALID_INDEX));
|
return JNI_TRUE;
|
}
|
|
if ((length < 0) || (length + index > arrayLength)) {
|
outStream_setError(out, JDWP_ERROR(INVALID_LENGTH));
|
return JNI_TRUE;
|
}
|
|
WITH_LOCAL_REFS(env, 1) {
|
|
jclass arrayClass;
|
char *signature = NULL;
|
char *componentSignature;
|
jbyte typeKey;
|
jvmtiError error;
|
|
arrayClass = JNI_FUNC_PTR(env,GetObjectClass)(env, array);
|
error = classSignature(arrayClass, &signature, NULL);
|
if (error != JVMTI_ERROR_NONE) {
|
goto err;
|
}
|
componentSignature = &signature[1];
|
typeKey = componentSignature[0];
|
|
(void)outStream_writeByte(out, typeKey);
|
(void)outStream_writeInt(out, length);
|
|
if (isObjectTag(typeKey)) {
|
writeObjectComponents(env, out, array, index, length);
|
} else {
|
switch (typeKey) {
|
case JDWP_TAG(BYTE):
|
writeByteComponents(env, out, array, index, length);
|
break;
|
|
case JDWP_TAG(CHAR):
|
writeCharComponents(env, out, array, index, length);
|
break;
|
|
case JDWP_TAG(FLOAT):
|
writeFloatComponents(env, out, array, index, length);
|
break;
|
|
case JDWP_TAG(DOUBLE):
|
writeDoubleComponents(env, out, array, index, length);
|
break;
|
|
case JDWP_TAG(INT):
|
writeIntComponents(env, out, array, index, length);
|
break;
|
|
case JDWP_TAG(LONG):
|
writeLongComponents(env, out, array, index, length);
|
break;
|
|
case JDWP_TAG(SHORT):
|
writeShortComponents(env, out, array, index, length);
|
break;
|
|
case JDWP_TAG(BOOLEAN):
|
writeBooleanComponents(env, out, array, index, length);
|
break;
|
|
default:
|
outStream_setError(out, JDWP_ERROR(INVALID_TAG));
|
break;
|
}
|
}
|
|
jvmtiDeallocate(signature);
|
|
err:;
|
|
} END_WITH_LOCAL_REFS(env);
|
|
if (JNI_FUNC_PTR(env,ExceptionOccurred)(env)) {
|
outStream_setError(out, JDWP_ERROR(INTERNAL));
|
JNI_FUNC_PTR(env,ExceptionClear)(env);
|
}
|
|
return JNI_TRUE;
|
}
|
|
static jdwpError
|
readBooleanComponents(JNIEnv *env, PacketInputStream *in,
|
jarray array, int index, int length)
|
{
|
int i;
|
jboolean component;
|
|
for (i = 0; (i < length) && !inStream_error(in); i++) {
|
component = inStream_readBoolean(in);
|
JNI_FUNC_PTR(env,SetBooleanArrayRegion)(env, array, index + i, 1, &component);
|
}
|
return inStream_error(in);
|
}
|
|
static jdwpError
|
readByteComponents(JNIEnv *env, PacketInputStream *in,
|
jarray array, int index, int length)
|
{
|
int i;
|
jbyte component;
|
|
for (i = 0; (i < length) && !inStream_error(in); i++) {
|
component = inStream_readByte(in);
|
JNI_FUNC_PTR(env,SetByteArrayRegion)(env, array, index + i, 1, &component);
|
}
|
return inStream_error(in);
|
}
|
|
static jdwpError
|
readCharComponents(JNIEnv *env, PacketInputStream *in,
|
jarray array, int index, int length)
|
{
|
int i;
|
jchar component;
|
|
for (i = 0; (i < length) && !inStream_error(in); i++) {
|
component = inStream_readChar(in);
|
JNI_FUNC_PTR(env,SetCharArrayRegion)(env, array, index + i, 1, &component);
|
}
|
return inStream_error(in);
|
}
|
|
static jdwpError
|
readShortComponents(JNIEnv *env, PacketInputStream *in,
|
jarray array, int index, int length)
|
{
|
int i;
|
jshort component;
|
|
for (i = 0; (i < length) && !inStream_error(in); i++) {
|
component = inStream_readShort(in);
|
JNI_FUNC_PTR(env,SetShortArrayRegion)(env, array, index + i, 1, &component);
|
}
|
return inStream_error(in);
|
}
|
|
static jdwpError
|
readIntComponents(JNIEnv *env, PacketInputStream *in,
|
jarray array, int index, int length)
|
{
|
int i;
|
jint component;
|
|
for (i = 0; (i < length) && !inStream_error(in); i++) {
|
component = inStream_readInt(in);
|
JNI_FUNC_PTR(env,SetIntArrayRegion)(env, array, index + i, 1, &component);
|
}
|
return inStream_error(in);
|
}
|
|
static jdwpError
|
readLongComponents(JNIEnv *env, PacketInputStream *in,
|
jarray array, int index, int length)
|
{
|
int i;
|
jlong component;
|
|
for (i = 0; (i < length) && !inStream_error(in); i++) {
|
component = inStream_readLong(in);
|
JNI_FUNC_PTR(env,SetLongArrayRegion)(env, array, index + i, 1, &component);
|
}
|
return inStream_error(in);
|
}
|
|
static jdwpError
|
readFloatComponents(JNIEnv *env, PacketInputStream *in,
|
jarray array, int index, int length)
|
{
|
int i;
|
jfloat component;
|
|
for (i = 0; (i < length) && !inStream_error(in); i++) {
|
component = inStream_readFloat(in);
|
JNI_FUNC_PTR(env,SetFloatArrayRegion)(env, array, index + i, 1, &component);
|
}
|
return inStream_error(in);
|
}
|
|
static jdwpError
|
readDoubleComponents(JNIEnv *env, PacketInputStream *in,
|
jarray array, int index, int length)
|
{
|
int i;
|
jdouble component;
|
|
for (i = 0; (i < length) && !inStream_error(in); i++) {
|
component = inStream_readDouble(in);
|
JNI_FUNC_PTR(env,SetDoubleArrayRegion)(env, array, index + i, 1, &component);
|
}
|
return inStream_error(in);
|
}
|
|
|
static jdwpError
|
readObjectComponents(JNIEnv *env, PacketInputStream *in,
|
jarray array, int index, int length)
|
/* char *componentSignature) */
|
{
|
int i;
|
|
for (i = 0; i < length; i++) {
|
jobject object = inStream_readObjectRef(env, in);
|
|
JNI_FUNC_PTR(env,SetObjectArrayElement)(env, array, index + i, object);
|
if (JNI_FUNC_PTR(env,ExceptionOccurred)(env)) {
|
/* caller will clear */
|
break;
|
}
|
}
|
|
return JDWP_ERROR(NONE);
|
}
|
|
|
static jboolean
|
setValues(PacketInputStream *in, PacketOutputStream *out)
|
{
|
JNIEnv *env = getEnv();
|
jdwpError serror = JDWP_ERROR(NONE);
|
int arrayLength;
|
jarray array;
|
jint index;
|
jint length;
|
|
array = inStream_readArrayRef(env, in);
|
if (inStream_error(in)) {
|
return JNI_TRUE;
|
}
|
index = inStream_readInt(in);
|
if (inStream_error(in)) {
|
return JNI_TRUE;
|
}
|
length = inStream_readInt(in);
|
if (inStream_error(in)) {
|
return JNI_TRUE;
|
}
|
|
arrayLength = JNI_FUNC_PTR(env,GetArrayLength)(env, array);
|
|
if ((index < 0) || (index > arrayLength - 1)) {
|
outStream_setError(out, JDWP_ERROR(INVALID_INDEX));
|
return JNI_TRUE;
|
}
|
|
if ((length < 0) || (length + index > arrayLength)) {
|
outStream_setError(out, JDWP_ERROR(INVALID_LENGTH));
|
return JNI_TRUE;
|
}
|
|
WITH_LOCAL_REFS(env, 1) {
|
|
jclass arrayClass;
|
char *signature = NULL;
|
char *componentSignature;
|
jvmtiError error;
|
|
arrayClass = JNI_FUNC_PTR(env,GetObjectClass)(env, array);
|
error = classSignature(arrayClass, &signature, NULL);
|
if (error != JVMTI_ERROR_NONE) {
|
goto err;
|
}
|
componentSignature = &signature[1];
|
|
switch (componentSignature[0]) {
|
case JDWP_TAG(OBJECT):
|
case JDWP_TAG(ARRAY):
|
serror = readObjectComponents(env, in, array, index, length);
|
break;
|
|
case JDWP_TAG(BYTE):
|
serror = readByteComponents(env, in, array, index, length);
|
break;
|
|
case JDWP_TAG(CHAR):
|
serror = readCharComponents(env, in, array, index, length);
|
break;
|
|
case JDWP_TAG(FLOAT):
|
serror = readFloatComponents(env, in, array, index, length);
|
break;
|
|
case JDWP_TAG(DOUBLE):
|
serror = readDoubleComponents(env, in, array, index, length);
|
break;
|
|
case JDWP_TAG(INT):
|
serror = readIntComponents(env, in, array, index, length);
|
break;
|
|
case JDWP_TAG(LONG):
|
serror = readLongComponents(env, in, array, index, length);
|
break;
|
|
case JDWP_TAG(SHORT):
|
serror = readShortComponents(env, in, array, index, length);
|
break;
|
|
case JDWP_TAG(BOOLEAN):
|
serror = readBooleanComponents(env, in, array, index, length);
|
break;
|
|
default:
|
{
|
ERROR_MESSAGE(("Invalid array component signature: %s",
|
componentSignature));
|
EXIT_ERROR(AGENT_ERROR_INVALID_OBJECT,NULL);
|
}
|
break;
|
}
|
|
jvmtiDeallocate(signature);
|
|
err:;
|
|
} END_WITH_LOCAL_REFS(env);
|
|
if (JNI_FUNC_PTR(env,ExceptionOccurred)(env)) {
|
/*
|
* TO DO: Check exception type
|
*/
|
serror = JDWP_ERROR(TYPE_MISMATCH);
|
JNI_FUNC_PTR(env,ExceptionClear)(env);
|
}
|
|
outStream_setError(out, serror);
|
return JNI_TRUE;
|
}
|
|
|
void *ArrayReference_Cmds[] = { (void *)0x3
|
,(void *)length
|
,(void *)getValues
|
,(void *)setValues};
|
