rik/jlibcom
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
7428d6590a7ae99b78d321d0af6cc7087fda142d
jlibcom/jni/SafeArray.cpp

2951 lines
76 KiB
C++
Raw Blame History

/*
* Copyright (c) 1999-2004 Sourceforge JACOB Project.
* All rights reserved. Originator: Dan Adler (http://danadler.com).
* Get more information about JACOB at http://sourceforge.net/projects/jacob-project
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "SafeArray.h"
// Win32 support for Ole Automation
#include <wchar.h>
#include <string.h>
#include <atlbase.h>
#include <objbase.h>
#include <oleauto.h>
#include <olectl.h>
#include "util.h"
extern "C"
{
#define V_FLD "m_pV"
static SAFEARRAY *makeArray(int vt, int nDims, long *lb, long *cel)
{
if (nDims == 1) {
// no need to alloc
SAFEARRAYBOUND sab;
sab.lLbound = lb[0];
sab.cElements = cel[0];
SAFEARRAY *sa = SafeArrayCreate(vt,1,&sab);
return sa;
} else {
SAFEARRAYBOUND* rgsaBounds = new SAFEARRAYBOUND[nDims];
for(int i=0;i<nDims;i++)
{
rgsaBounds[i].lLbound = lb[i];
rgsaBounds[i].cElements = cel[i];
}
SAFEARRAY *sa = SafeArrayCreate(vt,nDims,rgsaBounds);
delete[] rgsaBounds;
return sa;
}
}
VARIANT *extractWrapper(JNIEnv *env, jobject arg)
{
jclass argClass = env->GetObjectClass(arg);
jfieldID vf = env->GetFieldID( argClass, V_FLD, "I");
jint vnum = env->GetIntField(arg, vf);
if (vnum != NULL)
{
// if vnum is not NULL, then there is a Variant wrapper present
VARIANT *v = (VARIANT *)vnum;
return v;
}
return NULL;
}
// extract a SAFEARRAY from a SafeArray object
SAFEARRAY *extractSA(JNIEnv *env, jobject arg)
{
VARIANT *v = extractWrapper(env, arg);
if (v != NULL)
{
SAFEARRAY *sa = V_ARRAY(v);
return sa;
}
return NULL;
}
// deep copy a SAFEARRAY
SAFEARRAY *copySA(SAFEARRAY *psa)
{
// easiest way to make a deep copy is to use VariantCopy
VARTYPE vt;
SafeArrayGetVartype(psa, &vt);
VARIANT v1, v2;
VariantInit(&v1);
VariantInit(&v2);
V_VT(&v1) = VT_ARRAY | vt;
V_ARRAY(&v1) = psa;
VariantCopy(&v2, &v1);
SAFEARRAY *sa = V_ARRAY(&v2);
VariantInit(&v2); // make sure it's not owned by this variant
VariantClear(&v2);
VariantInit(&v1);
VariantClear(&v1);
return sa;
}
// create a VARIANT wrapper for the safearray
void setSA(JNIEnv *env, jobject arg, SAFEARRAY *sa, int copy)
{
// construct a variant to hold the result
// the variant then owns the array
jclass argClass = env->GetObjectClass(arg);
jfieldID ajf = env->GetFieldID( argClass, V_FLD, "I");
jint vnum = env->GetIntField(arg, ajf);
VARIANT *v = (VARIANT *)vnum;
if (v == NULL)
{
v = new VARIANT();
VariantInit(v);
}
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
V_VT(v) = VT_ARRAY | vt;
V_ARRAY(v) = copy ? copySA(sa) : sa;
env->SetIntField(arg, ajf, (unsigned int)v);
}
/*
* Class: SafeArray
* Method: init
* Signature: (I[I[I)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_init
(JNIEnv *env, jobject _this, jint vt, jintArray lb, jintArray cel)
{
jint *lbounds = env->GetIntArrayElements(lb, NULL);
jint *celems = env->GetIntArrayElements(cel, NULL);
int nDims = env->GetArrayLength(lb);
// array lengths must match
if (nDims != env->GetArrayLength(cel)) return;
// build the sa according to params
if ( nDims > 0 )
{
SAFEARRAY *sa = makeArray(vt, nDims, lbounds, celems);
env->ReleaseIntArrayElements(lb, lbounds, 0);
env->ReleaseIntArrayElements(cel, celems, 0);
jclass clazz = env->GetObjectClass(_this);
setSA(env, _this, sa, 0);
}
}
/*
* Class: SafeArray
* Method: clone
* Signature: ()Ljava/lang/Object;
*/
JNIEXPORT jobject JNICALL Java_com_jacob_com_SafeArray_clone
(JNIEnv *env, jobject _this)
{
SAFEARRAY *psa = extractSA(env, _this);
if (psa)
{
// prepare a new return value
jclass saClass = env->GetObjectClass(_this);
jmethodID saCons = env->GetMethodID(saClass, "<init>", "()V");
// construct an SA to return
jobject newSA = env->NewObject(saClass, saCons);
// wrap in a Variant
setSA(env, newSA, psa, 1);
return newSA;
}
return NULL;
}
/*
* Class: SafeArray
* Method: destroy
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_destroy
(JNIEnv *env, jobject _this)
{
VARIANT *v = extractWrapper(env, _this);
if (v) {
// this is the case where a Variant wrapper exists, in that
// case free the variant, but if there is just a raw SA, then
// the owning variant will free it
jclass saClass = env->GetObjectClass(_this);
jfieldID jf = env->GetFieldID(saClass, V_FLD, "I");
VariantClear(v);
delete v;
env->SetIntField(_this, jf, (unsigned int)0);
}
}
/*
* Class: SafeArray
* Method: getvt
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getvt
(JNIEnv *env, jobject _this)
{
SAFEARRAY *psa = extractSA(env, _this);
if (psa) {
VARTYPE vt;
SafeArrayGetVartype(psa, &vt);
return (jint)vt;
}
return NULL;
}
/*
* Class: SafeArray
* Method: reinit
* Signature: (LSafeArray;)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_reinit
(JNIEnv *env, jobject _this, jobject sa)
{
// what to do here?
}
/*
* Class: SafeArray
* Method: reinterpretType
* Signature: (I)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_reinterpretType
(JNIEnv *env, jobject _this, jint vt)
{
}
/*
* Class: SafeArray
* Method: getLBound
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getLBound__
(JNIEnv *env, jobject _this)
{
SAFEARRAY *psa = extractSA(env, _this);
if (psa) {
jint lb;
SafeArrayGetLBound(psa, 1, &lb);
return lb;
}
return NULL;
}
/*
* Class: SafeArray
* Method: getLBound
* Signature: (I)I
*/
JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getLBound__I
(JNIEnv *env, jobject _this, jint dim)
{
SAFEARRAY *psa = extractSA(env, _this);
if (psa) {
jint lb;
SafeArrayGetLBound(psa, dim, &lb);
return lb;
}
return NULL;
}
/*
* Class: SafeArray
* Method: getUBound
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getUBound__
(JNIEnv *env, jobject _this)
{
SAFEARRAY *psa = extractSA(env, _this);
if (psa) {
jint lb;
SafeArrayGetUBound(psa, 1, &lb);
return lb;
}
return NULL;
}
/*
* Class: SafeArray
* Method: getUBound
* Signature: (I)I
*/
JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getUBound__I
(JNIEnv *env, jobject _this, jint dim)
{
SAFEARRAY *psa = extractSA(env, _this);
if (psa) {
jint lb;
SafeArrayGetUBound(psa, dim, &lb);
return lb;
}
return NULL;
}
/*
* Class: SafeArray
* Method: getNumDim
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getNumDim
(JNIEnv *env, jobject _this)
{
SAFEARRAY *psa = extractSA(env, _this);
if (psa) {
return SafeArrayGetDim(psa);
}
return NULL;
}
/*
* Class: SafeArray
* Method: getFeatures
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getFeatures
(JNIEnv *env, jobject _this)
{
SAFEARRAY *psa = extractSA(env, _this);
if (psa) {
SafeArrayLock(psa);
jint features = psa->fFeatures;
SafeArrayUnlock(psa);
return features;
}
return NULL;
}
/*
* Class: SafeArray
* Method: getElemSize
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getElemSize
(JNIEnv *env, jobject _this)
{
SAFEARRAY *psa = extractSA(env, _this);
if (psa) {
jint siz = SafeArrayGetElemsize(psa);
return siz;
}
return NULL;
}
static int numElements(SAFEARRAY *psa)
{
int nDims = SafeArrayGetDim(psa);
int elems = 0;
for(int i=1;i<=nDims;i++) {
long lb, ub;
SafeArrayGetLBound(psa, i, &lb);
SafeArrayGetUBound(psa, i, &ub);
elems += ub - lb + 1;
}
return elems;
}
/*
* Class: SafeArray
* Method: fromCharArray
* Signature: ([C)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromCharArray
(JNIEnv *env, jobject _this, jcharArray a)
{
SAFEARRAY *psa = extractSA(env, _this);
if (!psa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
VARTYPE vt;
SafeArrayGetVartype(psa, &vt);
int len = env->GetArrayLength(a);
if (len > numElements(psa))
{
// max size of memcpy
len = numElements(psa);
}
// get the double array - don't make a copy
jchar *iarr = env->GetCharArrayElements(a, 0);
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
V_VT(&v) = VT_UI2;
for(int i=0;i<len;i++) {
V_UI2(&v) = iarr[i];
long x = i;
SafeArrayPutElement(psa,&x,&v);
}
} else if (vt == VT_UI2 || vt == VT_I2) {
void *pData;
SafeArrayAccessData(psa, &pData);
memcpy(pData, iarr, len*sizeof(jchar));
SafeArrayUnaccessData(psa);
} else {
ThrowComFail(env, "safearray cannot be assigned from char", 0);
}
env->ReleaseCharArrayElements(a, iarr, 0);
}
/*
* Class: SafeArray
* Method: fromIntArray
* Signature: ([I)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromIntArray
(JNIEnv *env, jobject _this, jintArray a)
{
SAFEARRAY *psa = extractSA(env, _this);
if (!psa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
VARTYPE vt;
SafeArrayGetVartype(psa, &vt);
int len = env->GetArrayLength(a);
if (len > numElements(psa))
{
// max size of memcpy
len = numElements(psa);
}
// get the int array - don't make a copy
jint *iarr = env->GetIntArrayElements(a, 0);
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
V_VT(&v) = VT_I4;
for(int i=0;i<len;i++) {
V_I4(&v) = iarr[i];
long x = i;
SafeArrayPutElement(psa,&x,&v);
}
} else if (vt == VT_I4) {
void *pData;
SafeArrayAccessData(psa, &pData);
memcpy(pData, iarr, len*sizeof(int));
SafeArrayUnaccessData(psa);
} else {
ThrowComFail(env, "safearray cannot be assigned from int", -1);
}
env->ReleaseIntArrayElements(a, iarr, 0);
}
/*
* Class: SafeArray
* Method: fromShortArray
* Signature: ([S)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromShortArray
(JNIEnv *env, jobject _this, jshortArray a)
{
SAFEARRAY *psa = extractSA(env, _this);
if (!psa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
VARTYPE vt;
SafeArrayGetVartype(psa, &vt);
int len = env->GetArrayLength(a);
if (len > numElements(psa))
{
// max size of memcpy
len = numElements(psa);
}
// get the short array - don't make a copy
jshort *iarr = env->GetShortArrayElements(a, 0);
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
V_VT(&v) = VT_I2;
for(int i=0;i<len;i++) {
V_I2(&v) = iarr[i];
long x = i;
SafeArrayPutElement(psa,&x,&v);
}
} else if (vt == VT_I2) {
void *pData;
SafeArrayAccessData(psa, &pData);
memcpy(pData, iarr, len*sizeof(short));
SafeArrayUnaccessData(psa);
} else {
ThrowComFail(env, "safearray cannot be assigned from short", -1);
}
env->ReleaseShortArrayElements(a, iarr, 0);
}
/*
* Class: SafeArray
* Method: fromDoubleArray
* Signature: ([D)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromDoubleArray
(JNIEnv *env, jobject _this, jdoubleArray a)
{
SAFEARRAY *psa = extractSA(env, _this);
if (!psa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
VARTYPE vt;
SafeArrayGetVartype(psa, &vt);
int len = env->GetArrayLength(a);
if (len > numElements(psa))
{
// max size of memcpy
len = numElements(psa);
}
// get the double array - don't make a copy
jdouble *iarr = env->GetDoubleArrayElements(a, 0);
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
V_VT(&v) = VT_R8;
for(int i=0;i<len;i++) {
V_R8(&v) = iarr[i];
long x = i;
SafeArrayPutElement(psa,&x,&v);
}
} else if (vt == VT_R8 || vt == VT_DATE) {
void *pData;
SafeArrayAccessData(psa, &pData);
memcpy(pData, iarr, len*sizeof(double));
SafeArrayUnaccessData(psa);
} else {
ThrowComFail(env, "safearray cannot be assigned from double", -1);
}
env->ReleaseDoubleArrayElements(a, iarr, 0);
}
/*
* Class: SafeArray
* Method: fromStringArray
* Signature: ([Ljava/lang/String;)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromStringArray
(JNIEnv *env, jobject _this, jobjectArray a)
{
SAFEARRAY *psa = extractSA(env, _this);
if (!psa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
VARTYPE vt;
SafeArrayGetVartype(psa, &vt);
int len = env->GetArrayLength(a);
if (len > numElements(psa))
{
// max size of memcpy
len = numElements(psa);
}
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
V_VT(&v) = VT_BSTR;
for(int i=0;i<len;i++) {
jstring s = (jstring)env->GetObjectArrayElement(a, i);
// jacob report 1224219 should use unicode and not UTF-8
// GetStringUTFChars() replaced with GetStringChars()
// (Variant modified in previous report)
const jchar *str = env->GetStringChars(s, NULL);
CComBSTR bs((LPCOLESTR)str); // SR cast SF 1689061
V_VT(&v) = VT_BSTR;
V_BSTR(&v) = bs.Copy();
long x = i;
SafeArrayPutElement(psa,&x,&v);
env->ReleaseStringChars(s, str);
VariantClear(&v);
}
} else if (vt == VT_BSTR) {
for(int i=0;i<len;i++) {
jstring s = (jstring)env->GetObjectArrayElement(a, i);
// jacob report 1224219 should use unicode and not UTF-8
// GetStringUTFChars() replaced with GetStringChars()
// (Variant modified in previous report)
const jchar *str = env->GetStringChars(s, NULL);
CComBSTR bs((LPCOLESTR)str); // SR cast SF 1689061
BSTR bstr = bs.Detach();
long x = i;
SafeArrayPutElement(psa,&x,bstr);
env->ReleaseStringChars(s, str);
}
} else {
ThrowComFail(env, "safearray cannot be assigned from string\n", 0);
}
}
/*
* Class: SafeArray
* Method: fromByteArray
* Signature: ([B)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromByteArray
(JNIEnv *env, jobject _this, jbyteArray a)
{
SAFEARRAY *psa = extractSA(env, _this);
if (!psa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
VARTYPE vt;
SafeArrayGetVartype(psa, &vt);
int len = env->GetArrayLength(a);
if (len > numElements(psa))
{
// max size of memcpy
len = numElements(psa);
}
// get the byte array - don't make a copy
jbyte *iarr = env->GetByteArrayElements(a, 0);
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
V_VT(&v) = VT_UI1;
for(int i=0;i<len;i++) {
V_UI1(&v) = iarr[i];
long x = i;
SafeArrayPutElement(psa,&x,&v);
}
} else if (vt == VT_UI1 || vt == VT_I1) {
jbyte *pData;
SafeArrayAccessData(psa, (void **)&pData);
memcpy(pData, iarr, len*sizeof(jbyte));
SafeArrayUnaccessData(psa);
} else {
ThrowComFail(env, "safearray cannot be assigned from byte", -1);
}
env->ReleaseByteArrayElements(a, iarr, 0);
}
/*
* Class: SafeArray
* Method: fromFloatArray
* Signature: ([F)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromFloatArray
(JNIEnv *env, jobject _this, jfloatArray a)
{
SAFEARRAY *psa = extractSA(env, _this);
if (!psa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
VARTYPE vt;
SafeArrayGetVartype(psa, &vt);
int len = env->GetArrayLength(a);
if (len > numElements(psa))
{
// max size of memcpy
len = numElements(psa);
}
// get the float array - don't make a copy
jfloat *iarr = env->GetFloatArrayElements(a, 0);
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
V_VT(&v) = VT_R4;
for(int i=0;i<len;i++) {
V_R4(&v) = iarr[i];
long x = i;
SafeArrayPutElement(psa,&x,&v);
}
} else if (vt == VT_R4) {
void *pData;
SafeArrayAccessData(psa, &pData);
memcpy(pData, iarr, len*sizeof(float));
SafeArrayUnaccessData(psa);
} else {
ThrowComFail(env, "safearray cannot be assigned from float", -1);
}
env->ReleaseFloatArrayElements(a, iarr, 0);
}
/*
* Class: SafeArray
* Method: fromBooleanArray
* Signature: ([Z)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromBooleanArray
(JNIEnv *env, jobject _this, jbooleanArray a)
{
SAFEARRAY *psa = extractSA(env, _this);
if (!psa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
VARTYPE vt;
SafeArrayGetVartype(psa, &vt);
int len = env->GetArrayLength(a);
if (len > numElements(psa))
{
// max size of memcpy
len = numElements(psa);
}
// get the boolean array - don't make a copy
jboolean *iarr = env->GetBooleanArrayElements(a, 0);
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
V_VT(&v) = VT_BOOL;
for(int i=0;i<len;i++) {
V_BOOL(&v) = iarr[i] ? VARIANT_TRUE : VARIANT_FALSE;
long x = i;
SafeArrayPutElement(psa,&x,&v);
}
} else if (vt == VT_BOOL) {
// jboolean is 1 byte and VARIANT_BOOL is 2
VARIANT_BOOL v;
for(int i=0;i<len;i++) {
v = iarr[i] ? VARIANT_TRUE : VARIANT_FALSE;
long x = i;
SafeArrayPutElement(psa,&x,&v);
}
} else {
ThrowComFail(env, "safearray cannot be assigned from boolean", -1);
}
env->ReleaseBooleanArrayElements(a, iarr, 0);
}
/*
* Class: SafeArray
* Method: fromVariantArray
* Signature: ([LVariant;)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromVariantArray
(JNIEnv *env, jobject _this, jobjectArray a)
{
SAFEARRAY *psa = extractSA(env, _this);
if (!psa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
VARTYPE vt;
SafeArrayGetVartype(psa, &vt);
int len = env->GetArrayLength(a);
if (len > numElements(psa))
{
// max size of memcpy
len = numElements(psa);
}
if (vt == VT_VARIANT) {
for(int i=0;i<len;i++) {
jobject var = env->GetObjectArrayElement(a, i);
VARIANT *v = extractVariant(env, var);
long x = i;
if (v) SafeArrayPutElement(psa,&x,v);
}
} else {
ThrowComFail(env, "safearray cannot be assigned from variant", -1);
}
}
/*
* Class: SafeArray
* Method: toCharArray
* Signature: ()[C
*/
JNIEXPORT jcharArray JNICALL Java_com_jacob_com_SafeArray_toCharArray
(JNIEnv *env, jobject _this)
{
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return NULL;
}
long lb, ub;
SafeArrayGetLBound(sa, 1, &lb);
SafeArrayGetUBound(sa, 1, &ub);
int num = ub - lb + 1;
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
if (vt == VT_UI2 || vt == VT_I2) {
jcharArray iarr = env->NewCharArray(num);
void *pData;
SafeArrayAccessData(sa, &pData);
env->SetCharArrayRegion(iarr, 0, num, (jchar *)pData);
SafeArrayUnaccessData(sa);
return iarr;
} else if (vt == VT_VARIANT) {
jcharArray iarr = env->NewCharArray(num);
VARIANT v;
VariantInit(&v);
for(int i=lb;i<=ub;i++) {
long ix = i;
SafeArrayGetElement(sa, &ix, (void*) &v);
if (FAILED(VariantChangeType(&v, &v, 0, VT_UI2))) {
return NULL;
}
jchar val = V_UI2(&v);
env->SetCharArrayRegion(iarr, i, 1, &val);
}
return iarr;
}
return NULL;
}
/*
* Class: SafeArray
* Method: toIntArray
* Signature: ()[I
*/
JNIEXPORT jintArray JNICALL Java_com_jacob_com_SafeArray_toIntArray
(JNIEnv *env, jobject _this)
{
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return NULL;
}
long lb, ub;
SafeArrayGetLBound(sa, 1, &lb);
SafeArrayGetUBound(sa, 1, &ub);
int num = ub - lb + 1;
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
if (vt == VT_I4) {
jintArray iarr = env->NewIntArray(num);
void *pData;
SafeArrayAccessData(sa, &pData);
env->SetIntArrayRegion(iarr, 0, num, (jint *)pData);
SafeArrayUnaccessData(sa);
return iarr;
} else if (vt == VT_VARIANT) {
jintArray iarr = env->NewIntArray(num);
VARIANT v;
VariantInit(&v);
for(int i=lb;i<=ub;i++) {
long ix = i;
SafeArrayGetElement(sa, &ix, (void*) &v);
if (FAILED(VariantChangeType(&v, &v, 0, VT_I4))) {
return NULL;
}
jint val = V_I4(&v);
env->SetIntArrayRegion(iarr, i, 1, &val);
}
return iarr;
}
return NULL;
}
/*
* Class: SafeArray
* Method: toShortArray
* Signature: ()[S
*/
JNIEXPORT jshortArray JNICALL Java_com_jacob_com_SafeArray_toShortArray
(JNIEnv *env, jobject _this)
{
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return NULL;
}
long lb, ub;
SafeArrayGetLBound(sa, 1, &lb);
SafeArrayGetUBound(sa, 1, &ub);
int num = ub - lb + 1;
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
if (vt == VT_I2) {
jshortArray iarr = env->NewShortArray(num);
void *pData;
SafeArrayAccessData(sa, &pData);
env->SetShortArrayRegion(iarr, 0, num, (jshort *)pData);
SafeArrayUnaccessData(sa);
return iarr;
} else if (vt == VT_VARIANT) {
jshortArray iarr = env->NewShortArray(num);
VARIANT v;
VariantInit(&v);
for(int i=lb;i<=ub;i++) {
long ix = i;
SafeArrayGetElement(sa, &ix, (void*) &v);
if (FAILED(VariantChangeType(&v, &v, 0, VT_I2))) {
return NULL;
}
jshort val = V_I2(&v);
env->SetShortArrayRegion(iarr, i, 1, &val);
}
return iarr;
}
return NULL;
}
/*
* Class: SafeArray
* Method: toDoubleArray
* Signature: ()[D
*/
JNIEXPORT jdoubleArray JNICALL Java_com_jacob_com_SafeArray_toDoubleArray
(JNIEnv *env, jobject _this)
{
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return NULL;
}
long lb, ub;
SafeArrayGetLBound(sa, 1, &lb);
SafeArrayGetUBound(sa, 1, &ub);
int num = ub - lb + 1;
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
if (vt == VT_R8) {
jdoubleArray iarr = env->NewDoubleArray(num);
void *pData;
SafeArrayAccessData(sa, &pData);
env->SetDoubleArrayRegion(iarr, 0, num, (jdouble *)pData);
SafeArrayUnaccessData(sa);
return iarr;
} else if (vt == VT_VARIANT) {
jdoubleArray iarr = env->NewDoubleArray(num);
VARIANT v;
VariantInit(&v);
for(int i=lb;i<=ub;i++) {
long ix = i;
SafeArrayGetElement(sa, &ix, (void*) &v);
if (FAILED(VariantChangeType(&v, &v, 0, VT_R8))) {
return NULL;
}
jdouble val = V_R8(&v);
env->SetDoubleArrayRegion(iarr, i, 1, &val);
}
return iarr;
}
return NULL;
}
/*
* Class: SafeArray
* Method: toStringArray
* Signature: ()[Ljava/lang/String;
*/
JNIEXPORT jobjectArray JNICALL Java_com_jacob_com_SafeArray_toStringArray
(JNIEnv *env, jobject _this)
{
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return NULL;
}
long lb, ub;
SafeArrayGetLBound(sa, 1, &lb);
SafeArrayGetUBound(sa, 1, &ub);
int num = ub - lb + 1;
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
if (vt == VT_VARIANT)
{
jclass sClass = env->FindClass("java/lang/String");
jobjectArray iarr = env->NewObjectArray(num, sClass, NULL);
VARIANT v;
VariantInit(&v);
for(int i=lb;i<=ub;i++) {
long ix = i;
SafeArrayGetElement(sa, &ix, (void*) &v);
if (FAILED(VariantChangeType(&v, &v, 0, VT_BSTR))) {
return NULL;
}
BSTR bs = V_BSTR(&v);
jstring js = env->NewString((jchar*)bs, SysStringLen(bs)); // SR cast SF 1689061
env->SetObjectArrayElement(iarr, i, js);
}
return iarr;
} else if (vt == VT_BSTR) {
jclass sClass = env->FindClass("java/lang/String");
jobjectArray iarr = env->NewObjectArray(num, sClass, NULL);
for(int i=lb;i<=ub;i++) {
BSTR bs = NULL;
long ix = i;
SafeArrayGetElement(sa, &ix, (void*) &bs);
jstring js = env->NewString((jchar*)bs, SysStringLen(bs)); // SR cast SF 1689061
env->SetObjectArrayElement(iarr, i, js);
}
return iarr;
}
ThrowComFail(env, "safearray cannot be converted to string[]", 0);
return NULL;
}
/*
* Class: SafeArray
* Method: toByteArray
* Signature: ()[B
*/
JNIEXPORT jbyteArray JNICALL Java_com_jacob_com_SafeArray_toByteArray
(JNIEnv *env, jobject _this)
{
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return NULL;
}
long lb, ub;
SafeArrayGetLBound(sa, 1, &lb);
SafeArrayGetUBound(sa, 1, &ub);
int num = ub - lb + 1;
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
if (vt == VT_I1 || vt == VT_UI1) {
jbyteArray iarr = env->NewByteArray(num);
jbyte *pData;
SafeArrayAccessData(sa, (void **)&pData);
env->SetByteArrayRegion(iarr, 0, num, pData);
SafeArrayUnaccessData(sa);
return iarr;
} else if (vt == VT_VARIANT) {
jbyteArray iarr = env->NewByteArray(num);
VARIANT v;
VariantInit(&v);
for(int i=lb,j=0;i<=ub;i++,j++) {
long ix = i;
SafeArrayGetElement(sa, &ix, (void*) &v);
if (FAILED(VariantChangeType(&v, &v, 0, VT_UI1))) {
return NULL;
}
jbyte val = V_UI1(&v);
env->SetByteArrayRegion(iarr, j, 1, &val);
}
return iarr;
}
return NULL;
}
/*
* Class: SafeArray
* Method: toFloatArray
* Signature: ()[F
*/
JNIEXPORT jfloatArray JNICALL Java_com_jacob_com_SafeArray_toFloatArray
(JNIEnv *env, jobject _this)
{
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return NULL;
}
long lb, ub;
SafeArrayGetLBound(sa, 1, &lb);
SafeArrayGetUBound(sa, 1, &ub);
int num = ub - lb + 1;
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
if (vt == VT_R4) {
jfloatArray iarr = env->NewFloatArray(num);
void *pData;
SafeArrayAccessData(sa, &pData);
env->SetFloatArrayRegion(iarr, 0, num, (jfloat *)pData);
SafeArrayUnaccessData(sa);
return iarr;
} else if (vt == VT_VARIANT) {
jfloatArray iarr = env->NewFloatArray(num);
VARIANT v;
VariantInit(&v);
for(int i=lb;i<=ub;i++) {
long ix = i;
SafeArrayGetElement(sa, &ix, (void*) &v);
if (FAILED(VariantChangeType(&v, &v, 0, VT_R4))) {
return NULL;
}
jfloat val = V_R4(&v);
env->SetFloatArrayRegion(iarr, i, 1, &val);
}
return iarr;
}
return NULL;
}
/*
* Class: SafeArray
* Method: toBooleanArray
* Signature: ()[Z
*/
JNIEXPORT jbooleanArray JNICALL Java_com_jacob_com_SafeArray_toBooleanArray
(JNIEnv *env, jobject _this)
{
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return NULL;
}
long lb, ub;
SafeArrayGetLBound(sa, 1, &lb);
SafeArrayGetUBound(sa, 1, &ub);
int num = ub - lb + 1;
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
if (vt == VT_BOOL) {
// need to loop because jboolean=1 byte and VARIANT_BOOL=2 bytes
jbooleanArray iarr = env->NewBooleanArray(num);
VARIANT_BOOL v;
for(int i=lb,j=0;i<=ub;i++,j++) {
long ix = i;
SafeArrayGetElement(sa, &ix, (void*) &v);
jboolean val = v == VARIANT_TRUE ? JNI_TRUE : JNI_FALSE;
env->SetBooleanArrayRegion(iarr, j, 1, &val);
}
return iarr;
} else if (vt == VT_VARIANT) {
jbooleanArray iarr = env->NewBooleanArray(num);
VARIANT v;
VariantInit(&v);
for(int i=lb;i<=ub;i++) {
long ix = i;
SafeArrayGetElement(sa, &ix, (void*) &v);
if (FAILED(VariantChangeType(&v, &v, 0, VT_BOOL))) {
return NULL;
}
jboolean val = V_BOOL(&v) == VARIANT_TRUE ? JNI_TRUE : JNI_FALSE;
env->SetBooleanArrayRegion(iarr, i, 1, &val);
}
return iarr;
}
return NULL;
}
/*
* Class: SafeArray
* Method: toVariantArray
* Signature: ()[LVariant;
*/
JNIEXPORT jobjectArray JNICALL Java_com_jacob_com_SafeArray_toVariantArray
(JNIEnv *env, jobject _this)
{
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return NULL;
}
long lb, ub;
SafeArrayGetLBound(sa, 1, &lb);
SafeArrayGetUBound(sa, 1, &ub);
int num = ub - lb + 1;
jclass vClass = env->FindClass("com/jacob/com/Variant");
// create an array of Variant's
jobjectArray varr = env->NewObjectArray(num, vClass, 0);
// fill them in
jmethodID variantCons =
env->GetMethodID(vClass, "<init>", "()V");
for(int i=lb;i<=ub;i++) {
long ix = i;
// construct a variant to return
jobject newVariant = env->NewObject(vClass, variantCons);
// get the VARIANT from the newVariant
VARIANT *v = extractVariant(env, newVariant);
SafeArrayGetElement(sa, &ix, (void*) v);
// put in object array
env->SetObjectArrayElement(varr, i, newVariant);
}
return varr;
}
// this is an ugly way to avoid copy/pasting the same code
#define GET1DCODE(varType, varAccess, jtyp) \
SAFEARRAY *sa = extractSA(env, _this); \
if (!sa) { \
ThrowComFail(env, "safearray object corrupted", -1); \
return NULL; \
} \
if (SafeArrayGetDim(sa) != 1) { \
ThrowComFail(env, "safearray is not 1D", -1); \
return NULL; \
} \
VARTYPE vt; \
SafeArrayGetVartype(sa, &vt); \
if (vt == VT_VARIANT) { \
VARIANT v; \
VariantInit(&v); \
SafeArrayGetElement(sa, &idx, (void*) &v); \
if (FAILED(VariantChangeType(&v, &v, 0, varType))) { \
ThrowComFail(env, "VariantChangeType failed", -1); \
return NULL; \
} \
return (jtyp)varAccess(&v); \
} else if (vt == varType) { \
jtyp jc; \
SafeArrayGetElement(sa, &idx, (void*) &jc); \
return jc; \
} else { \
return NULL; \
}
#define GET2DCODE(varType, varAccess, jtyp) \
SAFEARRAY *sa = extractSA(env, _this); \
if (!sa) { \
ThrowComFail(env, "safearray object corrupted", -1); \
return NULL; \
} \
if (SafeArrayGetDim(sa) != 2) { \
ThrowComFail(env, "safearray is not 2D", -1); \
return NULL; \
} \
long idx[2] = {i, j}; \
VARTYPE vt; \
SafeArrayGetVartype(sa, &vt); \
if (vt == VT_VARIANT) { \
VARIANT v; \
VariantInit(&v); \
SafeArrayGetElement(sa, idx, (void*) &v); \
if (FAILED(VariantChangeType(&v, &v, 0, varType))) { \
ThrowComFail(env, "VariantChangeType failed", -1); \
return NULL; \
} \
return (jtyp)varAccess(&v); \
} else if (vt == varType) { \
jtyp jc; \
SafeArrayGetElement(sa, idx, (void*) &jc); \
return jc; \
} else { \
return NULL; \
}
#define SET1DCODE(varType, varAccess) \
SAFEARRAY *sa = extractSA(env, _this); \
if (!sa) { \
ThrowComFail(env, "safearray object corrupted", -1); \
return; \
} \
if (SafeArrayGetDim(sa) != 1) { \
ThrowComFail(env, "safearray is not 1D", -1); \
return; \
} \
VARTYPE vt; \
SafeArrayGetVartype(sa, &vt); \
if (vt == VT_VARIANT) { \
VARIANT v; \
VariantInit(&v); \
V_VT(&v) = varType; \
varAccess(&v) = c; \
SafeArrayPutElement(sa,&idx,&v); \
} else if (vt == varType) { \
SafeArrayPutElement(sa,&idx,&c); \
} else { \
ThrowComFail(env, "safearray type mismatch", -1); \
} \
#define SET2DCODE(varType, varAccess) \
SAFEARRAY *sa = extractSA(env, _this); \
if (!sa) { \
ThrowComFail(env, "safearray object corrupted", -1); \
return; \
} \
if (SafeArrayGetDim(sa) != 2) { \
ThrowComFail(env, "safearray is not 2D", -1); \
return; \
} \
VARTYPE vt; \
SafeArrayGetVartype(sa, &vt); \
long idx[2] = {i,j}; \
if (vt == VT_VARIANT) { \
VARIANT v; \
VariantInit(&v); \
V_VT(&v) = varType; \
varAccess(&v) = c; \
SafeArrayPutElement(sa,idx,&v); \
} else if (vt == varType) { \
SafeArrayPutElement(sa,idx,&c); \
} else { \
ThrowComFail(env, "safearray type mismatch", -1); \
}
#define GETARRAYCODE(varType, varType2, varAccess, jtyp, jsetArr) \
SAFEARRAY *sa = extractSA(env, _this); \
if (!sa) { \
ThrowComFail(env, "safearray object corrupted", -1); \
return; \
} \
VARTYPE vt; \
SafeArrayGetVartype(sa, &vt); \
if (vt == varType || vt == varType2) { \
jtyp *pData; \
SafeArrayAccessData(sa, (void **)&pData); \
env->jsetArr(ja, ja_start, nelem, &pData[idx]); \
SafeArrayUnaccessData(sa); \
return; \
} else if (vt == VT_VARIANT) { \
VARIANT v; \
VariantInit(&v); \
for(int i=idx, j=ja_start;i<idx+nelem;i++,j++) { \
long ix = i; \
SafeArrayGetElement(sa, &ix, (void*) &v); \
if (FAILED(VariantChangeType(&v, &v, 0, varType))) { \
return; \
} \
jtyp val = varAccess(&v); \
env->jsetArr(ja, j, 1, &val); \
} \
}
#define SETARRAYCODE(varType, varType2, varAccess, jtyp, jgetArr, jrelArr) \
SAFEARRAY *psa = extractSA(env, _this); \
if (!psa) { \
ThrowComFail(env, "safearray object corrupted", -1); \
return; \
} \
VARTYPE vt; \
SafeArrayGetVartype(psa, &vt); \
jtyp *iarr = env->jgetArr(ja, 0); \
if (vt == VT_VARIANT) { \
VARIANT v; \
VariantInit(&v); \
V_VT(&v) = varType; \
for(int i=ja_start,j=idx;i<ja_start+nelem;i++,j++) { \
varAccess(&v) = iarr[i]; \
long x = j; \
SafeArrayPutElement(psa,&x,&v); \
} \
} else if (vt == varType || vt == varType2) { \
jtyp *pData; \
SafeArrayAccessData(psa, (void **)&pData); \
memcpy(&pData[idx], &iarr[ja_start], nelem*sizeof(jtyp)); \
SafeArrayUnaccessData(psa); \
} else { \
ThrowComFail(env, "safearray type mismatch", -1); \
} \
env->jrelArr(ja, iarr, 0);
/*
* Class: SafeArray
* Method: getChar
* Signature: (I)C
*/
JNIEXPORT jchar JNICALL Java_com_jacob_com_SafeArray_getChar__I
(JNIEnv *env, jobject _this, jint idx)
{
GET1DCODE(VT_UI2, V_UI2, jchar)
}
/*
* Class: SafeArray
* Method: getChar
* Signature: (II)C
*/
JNIEXPORT jchar JNICALL Java_com_jacob_com_SafeArray_getChar__II
(JNIEnv *env, jobject _this, jint i, jint j)
{
GET2DCODE(VT_UI2, V_UI2, jchar)
}
/*
* Class: SafeArray
* Method: setChar
* Signature: (IC)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setChar__IC
(JNIEnv *env, jobject _this, jint idx, jchar c)
{
SET1DCODE(VT_UI2, V_UI2);
}
/*
* Class: SafeArray
* Method: setChar
* Signature: (IIC)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setChar__IIC
(JNIEnv *env, jobject _this, jint i, jint j, jchar c)
{
SET2DCODE(VT_UI2, V_UI2);
}
/*
* Class: SafeArray
* Method: getChars
* Signature: (II[CI)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getChars
(JNIEnv *env, jobject _this, jint idx, jint nelem, jcharArray ja, jint ja_start)
{
GETARRAYCODE(VT_UI2, VT_I2, V_UI2, jchar, SetCharArrayRegion);
}
/*
* Class: SafeArray
* Method: setChars
* Signature: (II[CI)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setChars
(JNIEnv *env, jobject _this, jint idx, jint nelem, jcharArray ja, jint ja_start)
{
SETARRAYCODE(VT_UI2, VT_I2, V_UI2, jchar,
GetCharArrayElements, ReleaseCharArrayElements);
}
/*
* Class: SafeArray
* Method: getInt
* Signature: (I)I
*/
JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getInt__I
(JNIEnv *env, jobject _this, jint idx)
{
GET1DCODE(VT_I4, V_I4, jint)
}
/*
* Class: SafeArray
* Method: getInt
* Signature: (II)I
*/
JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getInt__II
(JNIEnv *env, jobject _this, jint i, jint j)
{
GET2DCODE(VT_I4, V_I4, jint)
}
/*
* Class: SafeArray
* Method: setInt
* Signature: (II)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setInt__II
(JNIEnv *env, jobject _this, jint idx, jint c)
{
SET1DCODE(VT_I4, V_I4);
}
/*
* Class: SafeArray
* Method: setInt
* Signature: (III)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setInt__III
(JNIEnv *env, jobject _this, jint i, jint j, jint c)
{
SET2DCODE(VT_I4, V_I4);
}
/*
* Class: SafeArray
* Method: getInts
* Signature: (II[II)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getInts
(JNIEnv *env, jobject _this, jint idx, jint nelem, jintArray ja, jint ja_start)
{
GETARRAYCODE(VT_I4, VT_I4, V_I4, jint, SetIntArrayRegion);
}
/*
* Class: SafeArray
* Method: setInts
* Signature: (II[II)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setInts
(JNIEnv *env, jobject _this, jint idx, jint nelem, jintArray ja, jint ja_start)
{
SETARRAYCODE(VT_I4, VT_I4, V_I4, jint,
GetIntArrayElements, ReleaseIntArrayElements);
}
/*
* Class: SafeArray
* Method: getShort
* Signature: (I)S
*/
JNIEXPORT jshort JNICALL Java_com_jacob_com_SafeArray_getShort__I
(JNIEnv *env, jobject _this, jint idx)
{
GET1DCODE(VT_I2, V_I2, jshort)
}
/*
* Class: SafeArray
* Method: getShort
* Signature: (II)S
*/
JNIEXPORT jshort JNICALL Java_com_jacob_com_SafeArray_getShort__II
(JNIEnv *env, jobject _this, jint i, jint j)
{
GET2DCODE(VT_I2, V_I2, jshort)
}
/*
* Class: SafeArray
* Method: setShort
* Signature: (IS)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setShort__IS
(JNIEnv *env, jobject _this, jint idx, jshort c)
{
SET1DCODE(VT_I2, V_I2);
}
/*
* Class: SafeArray
* Method: setShort
* Signature: (IIS)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setShort__IIS
(JNIEnv *env, jobject _this, jint i, jint j, jshort c)
{
SET2DCODE(VT_I2, V_I2);
}
/*
* Class: SafeArray
* Method: getShorts
* Signature: (II[SI)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getShorts
(JNIEnv *env, jobject _this, jint idx, jint nelem, jshortArray ja, jint ja_start)
{
GETARRAYCODE(VT_I2, VT_I2, V_I2, jshort, SetShortArrayRegion);
}
/*
* Class: SafeArray
* Method: setShorts
* Signature: (II[SI)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setShorts
(JNIEnv *env, jobject _this, jint idx, jint nelem, jshortArray ja, jint ja_start)
{
SETARRAYCODE(VT_I2, VT_I2, V_I2, jshort,
GetShortArrayElements, ReleaseShortArrayElements);
}
/*
* Class: SafeArray
* Method: getDouble
* Signature: (I)D
*/
JNIEXPORT jdouble JNICALL Java_com_jacob_com_SafeArray_getDouble__I
(JNIEnv *env, jobject _this, jint idx)
{
GET1DCODE(VT_R8, V_R8, jdouble)
}
/*
* Class: SafeArray
* Method: getDouble
* Signature: (II)D
*/
JNIEXPORT jdouble JNICALL Java_com_jacob_com_SafeArray_getDouble__II
(JNIEnv *env, jobject _this, jint i, jint j)
{
GET2DCODE(VT_R8, V_R8, jdouble)
}
/*
* Class: SafeArray
* Method: setDouble
* Signature: (ID)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setDouble__ID
(JNIEnv *env, jobject _this, jint idx, jdouble c)
{
SET1DCODE(VT_R8, V_R8);
}
/*
* Class: SafeArray
* Method: setDouble
* Signature: (IID)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setDouble__IID
(JNIEnv *env, jobject _this, jint i, jint j, jdouble c)
{
SET2DCODE(VT_R8, V_R8);
}
/*
* Class: SafeArray
* Method: getDoubles
* Signature: (II[DI)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getDoubles
(JNIEnv *env, jobject _this, jint idx, jint nelem, jdoubleArray ja, jint ja_start)
{
GETARRAYCODE(VT_R8, VT_R8, V_R8, jdouble, SetDoubleArrayRegion);
}
/*
* Class: SafeArray
* Method: setDoubles
* Signature: (II[DI)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setDoubles
(JNIEnv *env, jobject _this, jint idx, jint nelem, jdoubleArray ja, jint ja_start)
{
SETARRAYCODE(VT_R8, VT_R8, V_R8, jdouble,
GetDoubleArrayElements, ReleaseDoubleArrayElements);
}
/*
* Class: SafeArray
* Method: getString
* Signature: (I)Ljava/lang/String;
*
* There is supposed to be a leak in here, SourceForge 1224219
* that should be fixed with a call to
* "StrFree, Release or VariantClear to release the memory"
* waiting on the actual patch the submitter used before modifying this
*/
JNIEXPORT jstring JNICALL Java_com_jacob_com_SafeArray_getString__I
(JNIEnv *env, jobject _this, jint idx)
{
SAFEARRAY *psa = extractSA(env, _this);
if (!psa) {
ThrowComFail(env, "safearray object corrupted", -1); \
return NULL;
}
VARTYPE vt;
SafeArrayGetVartype(psa, &vt);
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
SafeArrayGetElement(psa, &idx, &v);
if (FAILED(VariantChangeType(&v, &v, 0, VT_BSTR))) {
return NULL;
}
BSTR bs = V_BSTR(&v);
jstring js = env->NewString((jchar*)bs, SysStringLen(bs)); // SR cast SF 1689061
// jacob report 1224219
// SafeArrayGetElement memory must be freed http://www.canaimasoft.com/f90VB/OnlineManuals/Reference/TH_31.htm
VariantClear(&v);
return js;
} else if (vt == VT_BSTR) {
BSTR bs = NULL;
SafeArrayGetElement(psa, &idx, &bs);
jstring js = env->NewString((jchar*)bs, SysStringLen(bs)); // SR cast SF 1689061
// jacob report 1224219
// SafeArrayGetElement memory must be freed http://www.canaimasoft.com/f90VB/OnlineManuals/Reference/TH_31.htm
if (bs) SysFreeString(bs);
return js;
}
ThrowComFail(env, "safearray cannot get string", 0);
return NULL;
}
/*
* Class: SafeArray
* Method: getString
* Signature: (II)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_com_jacob_com_SafeArray_getString__II
(JNIEnv *env, jobject _this, jint i, jint j)
{
SAFEARRAY *psa = extractSA(env, _this);
if (!psa) {
ThrowComFail(env, "safearray object corrupted", -1); \
return NULL;
}
VARTYPE vt;
SafeArrayGetVartype(psa, &vt);
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
long idx[2] = {i, j};
SafeArrayGetElement(psa, idx, &v);
if (FAILED(VariantChangeType(&v, &v, 0, VT_BSTR))) {
return NULL;
}
BSTR bs = V_BSTR(&v);
jstring js = env->NewString((jchar*)bs, SysStringLen(bs)); // SR cast SF 1689061
return js;
} else if (vt == VT_BSTR) {
long idx[2] = {i, j};
BSTR bs = NULL;
SafeArrayGetElement(psa, idx, &bs);
jstring js = env->NewString((jchar*)bs, SysStringLen(bs)); // SR cast SF 1689061
return js;
}
ThrowComFail(env, "safearray cannot get string", 0);
return NULL;
}
/*
* Class: SafeArray
* Method: setString
* Signature: (ILjava/lang/String;)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setString__ILjava_lang_String_2
(JNIEnv *env, jobject _this, jint idx, jstring s)
{
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1); \
return;
}
if (SafeArrayGetDim(sa) != 1) {
ThrowComFail(env, "safearray not 1D", -1); \
return;
}
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
const char *str = env->GetStringUTFChars(s, NULL);
CComBSTR bs(str);
V_VT(&v) = VT_BSTR;
V_BSTR(&v) = bs.Copy();
SafeArrayPutElement(sa,&idx,&v); \
env->ReleaseStringUTFChars(s, str);
VariantClear(&v);
} else if (vt == VT_BSTR) {
const char *str = env->GetStringUTFChars(s, NULL);
CComBSTR bs(str);
SafeArrayPutElement(sa,&idx,bs.Detach());
env->ReleaseStringUTFChars(s, str);
} else {
ThrowComFail(env, "safearray cannot set string", 0);
}
}
/*
* Class: SafeArray
* Method: setString
* Signature: (IILjava/lang/String;)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setString__IILjava_lang_String_2
(JNIEnv *env, jobject _this, jint i, jint j, jstring s)
{
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
if (SafeArrayGetDim(sa) != 2) {
ThrowComFail(env, "safearray is not 2D", -1);
return;
}
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
const char *str = env->GetStringUTFChars(s, NULL);
CComBSTR bs(str);
V_VT(&v) = VT_BSTR;
V_BSTR(&v) = bs.Copy();
long idx[2] = {i,j};
SafeArrayPutElement(sa,idx,&v);
env->ReleaseStringUTFChars(s, str);
VariantClear(&v);
} else if (vt == VT_BSTR) {
long idx[2] = {i,j};
const char *str = env->GetStringUTFChars(s, NULL);
CComBSTR bs(str);
SafeArrayPutElement(sa,idx,bs.Detach());
env->ReleaseStringUTFChars(s, str);
} else {
ThrowComFail(env, "safearray cannot set string", 0);
}
}
/*
* Class: SafeArray
* Method: getStrings
* Signature: (II[Ljava/lang/String;I)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getStrings
(JNIEnv *env, jobject _this, jint idx, jint nelem, jobjectArray ja, jint ja_start)
{
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
long lb, ub;
SafeArrayGetLBound(sa, 1, &lb);
SafeArrayGetUBound(sa, 1, &ub);
int num = ub - lb + 1;
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
if (vt == VT_VARIANT)
{
VARIANT v;
for(int i=idx, j=ja_start;i<idx+nelem;i++,j++)
{
long ix = i;
SafeArrayGetElement(sa, &ix, (void*) &v);
if (FAILED(VariantChangeType(&v, &v, 0, VT_BSTR))) {
return;
}
BSTR bs = V_BSTR(&v);
jstring js = env->NewString((jchar*)bs, SysStringLen(bs)); // SR cast SF 1689061
env->SetObjectArrayElement(ja, j, js);
VariantClear(&v);
}
}
else if (vt == VT_BSTR)
{
BSTR bs = NULL;
for(int i=idx, j=ja_start;i<idx+nelem;i++,j++)
{
long ix = i;
SafeArrayGetElement(sa, &ix, (void*) &bs);
jstring js = env->NewString((jchar*)bs, SysStringLen(bs)); // SR cast SF 1689061
env->SetObjectArrayElement(ja, j, js);
}
} else {
ThrowComFail(env, "safearray cannot get strings", 0);
}
}
/*
* Class: SafeArray
* Method: setStrings
* Signature: (II[Ljava/lang/String;I)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setStrings
(JNIEnv *env, jobject _this, jint idx, jint nelem, jobjectArray ja, jint ja_start)
{
SAFEARRAY *psa = extractSA(env, _this);
if (!psa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
VARTYPE vt;
SafeArrayGetVartype(psa, &vt);
int len = env->GetArrayLength(ja);
if (len > numElements(psa))
{
len = numElements(psa);
}
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
for(int i=ja_start,j=idx;i<ja_start+nelem;i++,j++)
{
jstring s = (jstring)env->GetObjectArrayElement(ja, i);
const char *str = env->GetStringUTFChars(s, NULL);
CComBSTR bs(str);
V_VT(&v) = VT_BSTR;
V_BSTR(&v) = bs.Copy();
long x = j;
SafeArrayPutElement(psa,&x,&v);
VariantClear(&v);
env->ReleaseStringUTFChars(s, str);
}
} else if (vt == VT_BSTR) {
for(int i=ja_start,j=idx;i<ja_start+nelem;i++,j++)
{
jstring s = (jstring)env->GetObjectArrayElement(ja, i);
const char *str = env->GetStringUTFChars(s, NULL);
CComBSTR bs(str);
long x = j;
SafeArrayPutElement(psa,&x,bs.Detach());
env->ReleaseStringUTFChars(s, str);
}
} else {
ThrowComFail(env, "safearray cannot set strings", 0);
}
}
/*
* Class: SafeArray
* Method: getByte
* Signature: (I)B
*/
JNIEXPORT jbyte JNICALL Java_com_jacob_com_SafeArray_getByte__I
(JNIEnv *env, jobject _this, jint idx)
{
GET1DCODE(VT_UI1, V_UI1, jbyte)
}
/*
* Class: SafeArray
* Method: getByte
* Signature: (II)B
*/
JNIEXPORT jbyte JNICALL Java_com_jacob_com_SafeArray_getByte__II
(JNIEnv *env, jobject _this, jint i, jint j)
{
GET2DCODE(VT_UI1, V_UI1, jbyte)
}
/*
* Class: SafeArray
* Method: setByte
* Signature: (IB)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setByte__IB
(JNIEnv *env, jobject _this, jint idx, jbyte c)
{
SET1DCODE(VT_UI1, V_UI1);
}
/*
* Class: SafeArray
* Method: setByte
* Signature: (IIB)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setByte__IIB
(JNIEnv *env, jobject _this, jint i, jint j, jbyte c)
{
SET2DCODE(VT_UI1, V_UI1);
}
/*
* Class: SafeArray
* Method: getBytes
* Signature: (II[BI)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getBytes
(JNIEnv *env, jobject _this, jint idx, jint nelem, jbyteArray ja, jint ja_start)
{
GETARRAYCODE(VT_UI1, VT_I1, V_UI1, jbyte, SetByteArrayRegion);
}
/*
* Class: SafeArray
* Method: setBytes
* Signature: (II[BI)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setBytes
(JNIEnv *env, jobject _this, jint idx, jint nelem, jbyteArray ja, jint ja_start)
{
SETARRAYCODE(VT_UI1, VT_I1, V_UI1, jbyte,
GetByteArrayElements, ReleaseByteArrayElements);
}
/*
* Class: SafeArray
* Method: getFloat
* Signature: (I)F
*/
JNIEXPORT jfloat JNICALL Java_com_jacob_com_SafeArray_getFloat__I
(JNIEnv *env, jobject _this, jint idx)
{
GET1DCODE(VT_R4, V_R4, jfloat)
}
/*
* Class: SafeArray
* Method: getFloat
* Signature: (II)F
*/
JNIEXPORT jfloat JNICALL Java_com_jacob_com_SafeArray_getFloat__II
(JNIEnv *env, jobject _this, jint i, jint j)
{
GET2DCODE(VT_R4, V_R4, jfloat)
}
/*
* Class: SafeArray
* Method: setFloat
* Signature: (IF)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setFloat__IF
(JNIEnv *env, jobject _this, jint idx, jfloat c)
{
SET1DCODE(VT_R4, V_R4);
}
/*
* Class: SafeArray
* Method: setFloat
* Signature: (IIF)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setFloat__IIF
(JNIEnv *env, jobject _this, jint i, jint j, jfloat c)
{
SET2DCODE(VT_R4, V_R4);
}
/*
* Class: SafeArray
* Method: getFloats
* Signature: (II[FI)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getFloats
(JNIEnv *env, jobject _this, jint idx, jint nelem, jfloatArray ja, jint ja_start)
{
GETARRAYCODE(VT_R4, VT_R4, V_R4, jfloat, SetFloatArrayRegion);
}
/*
* Class: SafeArray
* Method: setFloats
* Signature: (II[FI)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setFloats
(JNIEnv *env, jobject _this, jint idx, jint nelem, jfloatArray ja, jint ja_start)
{
SETARRAYCODE(VT_R4, VT_R4, V_R4, jfloat,
GetFloatArrayElements, ReleaseFloatArrayElements);
}
/*
* Class: SafeArray
* Method: getBoolean
* Signature: (I)Z
*/
JNIEXPORT jboolean JNICALL Java_com_jacob_com_SafeArray_getBoolean__I
(JNIEnv *env, jobject _this, jint idx)
{
// code is inline because of size mismatch
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return NULL;
}
if (SafeArrayGetDim(sa) != 1) {
ThrowComFail(env, "safearray not 1D", -1); \
return NULL;
}
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
SafeArrayGetElement(sa, &idx, (void*) &v);
if (FAILED(VariantChangeType(&v, &v, 0, VT_BOOL))) {
ThrowComFail(env, "safearray change type failed", -1); \
return NULL;
}
jboolean jb = V_BOOL(&v) == VARIANT_TRUE ? JNI_TRUE: JNI_FALSE;
return jb;
} else if (vt == VT_BOOL) {
VARIANT_BOOL vb;
SafeArrayGetElement(sa, &idx, (void*) &vb);
jboolean jb = vb == VARIANT_TRUE ? JNI_TRUE: JNI_FALSE;
return jb;
} else {
return NULL;
}
}
/*
* Class: SafeArray
* Method: getBoolean
* Signature: (II)Z
*/
JNIEXPORT jboolean JNICALL Java_com_jacob_com_SafeArray_getBoolean__II
(JNIEnv *env, jobject _this, jint i, jint j)
{
// code is inline because of size mismatch
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return NULL;
}
if (SafeArrayGetDim(sa) != 2) {
ThrowComFail(env, "safearray is not 2D", -1);
return NULL;
}
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
long idx[2] = {i,j};
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
SafeArrayGetElement(sa, idx, (void*) &v);
if (FAILED(VariantChangeType(&v, &v, 0, VT_BOOL))) {
ThrowComFail(env, "safearray change type failed", -1);
return NULL;
}
jboolean jb = V_BOOL(&v) == VARIANT_TRUE ? JNI_TRUE: JNI_FALSE;
return jb;
} else if (vt == VT_BOOL) {
VARIANT_BOOL vb;
SafeArrayGetElement(sa, idx, (void*) &vb);
jboolean jb = vb == VARIANT_TRUE ? JNI_TRUE: JNI_FALSE;
return jb;
} else {
return NULL;
}
}
/*
* Class: SafeArray
* Method: setBoolean
* Signature: (IZ)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setBoolean__IZ
(JNIEnv *env, jobject _this, jint idx, jboolean c)
{
// code is inline because of size mismatch
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
if (SafeArrayGetDim(sa) != 1) {
ThrowComFail(env, "safearray is not 1D", -1);
return;
}
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
V_VT(&v) = VT_BOOL;
V_BOOL(&v) = c == JNI_TRUE ? VARIANT_TRUE : VARIANT_FALSE;
SafeArrayPutElement(sa,&idx,&v);
} else if (vt == VT_BOOL) {
VARIANT_BOOL vb = c == JNI_TRUE ? VARIANT_TRUE : VARIANT_FALSE;
SafeArrayPutElement(sa,&idx,&vb);
} else {
ThrowComFail(env, "safearray type mismatch", -1);
}
}
/*
* Class: SafeArray
* Method: setBoolean
* Signature: (IIZ)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setBoolean__IIZ
(JNIEnv *env, jobject _this, jint i, jint j, jboolean c)
{
// code is inline because of size mismatch
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
if (SafeArrayGetDim(sa) != 2) {
ThrowComFail(env, "safearray is not 2D", -1);
return;
}
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
long idx[2] = {i,j};
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
V_VT(&v) = VT_BOOL;
V_BOOL(&v) = c == JNI_TRUE ? VARIANT_TRUE : VARIANT_FALSE;
SafeArrayPutElement(sa,idx,&v);
} else if (vt == VT_BOOL) {
VARIANT_BOOL vb = c == JNI_TRUE ? VARIANT_TRUE : VARIANT_FALSE;
SafeArrayPutElement(sa,idx,&vb);
} else {
ThrowComFail(env, "safearray type mismatch", -1);
}
}
/*
* Class: SafeArray
* Method: getBooleans
* Signature: (II[ZI)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getBooleans
(JNIEnv *env, jobject _this, jint idx, jint nelem, jbooleanArray ja, jint ja_start)
{
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
long lb, ub;
SafeArrayGetLBound(sa, 1, &lb);
SafeArrayGetUBound(sa, 1, &ub);
int num = ub - lb + 1;
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
if (vt == VT_BOOL) {
VARIANT_BOOL v;
for(int i=idx, j=ja_start;i<idx+nelem;i++,j++) {
long ix = i;
SafeArrayGetElement(sa, &ix, (void*) &v);
jboolean val = v == VARIANT_TRUE ? JNI_TRUE : JNI_FALSE;
env->SetBooleanArrayRegion(ja, j, 1, &val);
}
} else if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
for(int i=idx, j=ja_start;i<idx+nelem;i++,j++) {
long ix = i;
SafeArrayGetElement(sa, &ix, (void*) &v);
if (FAILED(VariantChangeType(&v, &v, 0, VT_BOOL))) {
return;
}
jboolean val = V_BOOL(&v) == VARIANT_TRUE ? JNI_TRUE : JNI_FALSE;
env->SetBooleanArrayRegion(ja, j, 1, &val);
}
}
}
/*
* Class: SafeArray
* Method: setBooleans
* Signature: (II[ZI)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setBooleans
(JNIEnv *env, jobject _this, jint idx, jint nelem, jbooleanArray ja, jint ja_start)
{
SAFEARRAY *psa = extractSA(env, _this);
if (!psa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
VARTYPE vt;
SafeArrayGetVartype(psa, &vt);
int len = env->GetArrayLength(ja);
if (len > numElements(psa))
{
len = numElements(psa);
}
jboolean *iarr = env->GetBooleanArrayElements(ja, 0);
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
V_VT(&v) = VT_BOOL;
for(int i=ja_start,j=idx;i<ja_start+nelem;i++,j++) {
V_BOOL(&v) = iarr[i] == JNI_TRUE ? VARIANT_TRUE : VARIANT_FALSE;
long x = j;
SafeArrayPutElement(psa,&x,&v);
}
} else if (vt == VT_BOOL) {
VARIANT_BOOL v;
for(int i=ja_start,j=idx;i<ja_start+nelem;i++,j++) {
v = iarr[i] == JNI_TRUE ? VARIANT_TRUE : VARIANT_FALSE;
long x = j;
SafeArrayPutElement(psa,&x,&v);
}
} else {
ThrowComFail(env, "safearray type mismatch", -1);
}
env->ReleaseBooleanArrayElements(ja, iarr, 0);
}
/*
* Class: SafeArray
* Method: getVariant
* Signature: (I)LVariant;
*/
JNIEXPORT jobject JNICALL Java_com_jacob_com_SafeArray_getVariant__I
(JNIEnv *env, jobject _this, jint idx)
{
SAFEARRAY *psa = extractSA(env, _this);
if (!psa) {
ThrowComFail(env, "safearray object corrupted", -1);
return NULL;
}
VARTYPE vt;
SafeArrayGetVartype(psa, &vt);
// prepare a new return value
jclass variantClass = env->FindClass("com/jacob/com/Variant");
jmethodID variantCons =
env->GetMethodID(variantClass, "<init>", "()V");
// construct a variant to return
jobject newVariant = env->NewObject(variantClass, variantCons);
// get the VARIANT from the newVariant
VARIANT *v = extractVariant(env, newVariant);
if (vt == VT_VARIANT) {
SafeArrayGetElement(psa, &idx, v);
} else if (vt == VT_DISPATCH || vt == VT_UNKNOWN) {
IDispatch *disp;
SafeArrayGetElement(psa, &idx, (void *)&disp);
VariantClear(v); // whatever was there before
V_VT(v) = VT_DISPATCH;
V_DISPATCH(v) = disp;
// I am handing the pointer to COM
disp->AddRef();
} else {
ThrowComFail(env, "safearray type is not variant/dispatch", -1);
}
return newVariant;
}
/*
* Class: SafeArray
* Method: getVariant
* Signature: (II)LVariant;
*/
JNIEXPORT jobject JNICALL Java_com_jacob_com_SafeArray_getVariant__II
(JNIEnv *env, jobject _this, jint i, jint j)
{
SAFEARRAY *psa = extractSA(env, _this);
if (!psa) {
ThrowComFail(env, "safearray object corrupted", -1);
return NULL;
}
VARTYPE vt;
SafeArrayGetVartype(psa, &vt);
// prepare a new return value
jclass variantClass = env->FindClass("com/jacob/com/Variant");
jmethodID variantCons =
env->GetMethodID(variantClass, "<init>", "()V");
// construct a variant to return
jobject newVariant = env->NewObject(variantClass, variantCons);
// get the VARIANT from the newVariant
VARIANT *v = extractVariant(env, newVariant);
long idx[2] = {i,j};
if (vt == VT_VARIANT) {
SafeArrayGetElement(psa, idx, v);
} else if (vt == VT_DISPATCH || vt == VT_UNKNOWN) {
IDispatch *disp;
SafeArrayGetElement(psa, idx, (void *)&disp);
VariantClear(v); // whatever was there before
V_VT(v) = VT_DISPATCH;
V_DISPATCH(v) = disp;
// I am handing the pointer to COM
disp->AddRef();
} else {
ThrowComFail(env, "safearray type is not variant/dispatch", -1);
}
return newVariant;
}
/*
* Class: SafeArray
* Method: setVariant
* Signature: (ILVariant;)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setVariant__ILcom_jacob_com_Variant_2
(JNIEnv *env, jobject _this, jint idx, jobject s)
{
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
if (SafeArrayGetDim(sa) != 1) {
ThrowComFail(env, "safearray is not 1D", -1);
return;
}
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
VARIANT *v = extractVariant(env, s);
if (vt == VT_VARIANT) {
SafeArrayPutElement(sa,&idx,v);
} else if (vt == VT_DISPATCH || vt == VT_UNKNOWN) {
if (V_VT(v) != VT_DISPATCH) {
ThrowComFail(env, "variant is not dispatch", -1);
return;
}
IDispatch *disp = V_DISPATCH(v);
disp->AddRef();
SafeArrayPutElement(sa,&idx,disp);
} else {
ThrowComFail(env, "safearray type is not variant/dispatch", -1);
}
}
/*
* Class: SafeArray
* Method: setVariant
* Signature: (IILVariant;)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setVariant__IILcom_jacob_com_Variant_2
(JNIEnv *env, jobject _this, jint i, jint j, jobject s)
{
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
if (SafeArrayGetDim(sa) != 2) {
ThrowComFail(env, "safearray is not 2D", -1);
return;
}
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
long idx[2] = {i, j};
if (vt == VT_VARIANT) {
VARIANT *v = extractVariant(env, s);
SafeArrayPutElement(sa,idx,v);
} else if (vt == VT_DISPATCH || vt == VT_UNKNOWN) {
VARIANT *v = extractVariant(env, s);
if (V_VT(v) != VT_DISPATCH) {
ThrowComFail(env, "variant is not dispatch", -1);
return;
}
IDispatch *disp = V_DISPATCH(v);
SafeArrayPutElement(sa,idx,disp);
} else {
ThrowComFail(env, "safearray type is not variant/dispatch", -1);
}
}
/*
* Class: SafeArray
* Method: getVariants
* Signature: (II[LVariant;I)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getVariants
(JNIEnv *env, jobject _this, jint idx, jint nelem, jobjectArray ja, jint ja_start)
{
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
long lb, ub;
SafeArrayGetLBound(sa, 1, &lb);
SafeArrayGetUBound(sa, 1, &ub);
int num = ub - lb + 1;
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
if (vt == VT_VARIANT)
{
jclass variantClass = env->FindClass("com/jacob/com/Variant");
jmethodID variantCons =
env->GetMethodID(variantClass, "<init>", "()V");
for(int i=idx, j=ja_start;i<idx+nelem;i++,j++)
{
long ix = i;
// construct a variant to return
jobject newVariant = env->NewObject(variantClass, variantCons);
// get the VARIANT from the newVariant
VARIANT *v = extractVariant(env, newVariant);
SafeArrayGetElement(sa, &ix, (void*) v);
env->SetObjectArrayElement(ja, j, newVariant);
}
} else {
ThrowComFail(env, "safearray type is not variant", -1);
}
}
/*
* Class: SafeArray
* Method: setVariants
* Signature: (II[LVariant;I)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setVariants
(JNIEnv *env, jobject _this, jint idx, jint nelem, jobjectArray ja, jint ja_start)
{
SAFEARRAY *psa = extractSA(env, _this);
if (!psa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
VARTYPE vt;
SafeArrayGetVartype(psa, &vt);
int len = env->GetArrayLength(ja);
if (len > numElements(psa))
{
len = numElements(psa);
}
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
for(int i=ja_start,j=idx;i<ja_start+nelem;i++,j++)
{
jobject var = env->GetObjectArrayElement(ja, i);
VARIANT *v = extractVariant(env, var);
long x = j;
SafeArrayPutElement(psa,&x,v);
}
} else {
ThrowComFail(env, "safearray type is not variant", -1);
}
}
/* PLEASE NOTE THE LINE:
jint *jIndices = env->GetIntArrayElements(indices, NULL);
which I added to replace "long idx[2] = {i,j};" from the 2D case.
Not sure if this is correct. Also, check that I am doing the null test and
dimension test correctly.
*/
#define GETNDCODE(varType, varAccess, jtyp) \
SAFEARRAY *sa = extractSA(env, _this); \
if (!sa) { \
ThrowComFail(env, "safearray object corrupted", -1); \
return NULL; \
} \
jint *jIndices = env->GetIntArrayElements(indices, NULL); \
if (!jIndices) { \
ThrowComFail(env, "null indices array", -1); \
return NULL; \
} \
if (SafeArrayGetDim(sa) != env->GetArrayLength(indices)) { \
ThrowComFail(env, "safearray and indices array have different dimensions", -1); \
return NULL; \
} \
VARTYPE vt; \
SafeArrayGetVartype(sa, &vt); \
if (vt == VT_VARIANT) { \
VARIANT v; \
VariantInit(&v); \
SafeArrayGetElement(sa, jIndices, (void*) &v); \
if (FAILED(VariantChangeType(&v, &v, 0, varType))) { \
ThrowComFail(env, "VariantChangeType failed", -1); \
return NULL; \
} \
return (jtyp)varAccess(&v); \
} else if (vt == varType) { \
jtyp jc; \
SafeArrayGetElement(sa, jIndices, (void*) &jc); \
return jc; \
} else { \
return NULL; \
}
//---------------------------------
/* PLEASE NOTE THE LINE:
jint *jIndices = env->GetIntArrayElements(indices, NULL);
which I added to replace "long idx[2] = {i,j};" from the 2D case.
Not sure if this is correct. Also, check that I am doing the null test and
dimension test correctly.
*/
#define SETNDCODE(varType, varAccess) \
SAFEARRAY *sa = extractSA(env, _this); \
if (!sa) { \
ThrowComFail(env, "safearray object corrupted", -1); \
return; \
} \
jint *jIndices = env->GetIntArrayElements(indices, NULL); \
if (!jIndices) { \
ThrowComFail(env, "null indices array", -1); \
return; \
} \
if (SafeArrayGetDim(sa) != env->GetArrayLength(indices)) { \
ThrowComFail(env, "safearray and indices array have different dimensions", -1); \
return; \
} \
VARTYPE vt; \
SafeArrayGetVartype(sa, &vt); \
if (vt == VT_VARIANT) { \
VARIANT v; \
VariantInit(&v); \
V_VT(&v) = varType; \
varAccess(&v) = c; \
SafeArrayPutElement(sa,jIndices,&v); \
} else if (vt == varType) { \
SafeArrayPutElement(sa, jIndices,&c); \
} else { \
ThrowComFail(env, "safearray type mismatch", -1); \
}
/*
* Class: com_jacob_com_SafeArray
* Method: getVariant
* Signature: ([I)Lcom/jacob/com/Variant;
*/
JNIEXPORT jobject JNICALL Java_com_jacob_com_SafeArray_getVariant___3I
(JNIEnv *env, jobject _this, jintArray indices)
{
SAFEARRAY *psa = extractSA(env, _this);
if (!psa) {
ThrowComFail(env, "safearray object corrupted", -1);
return NULL;
}
VARTYPE vt;
SafeArrayGetVartype(psa, &vt);
// ??? Not sure if this is correct type for call to SafeArrayGetElement()
jint *jIndices = env->GetIntArrayElements(indices, NULL);
if (!jIndices) {
ThrowComFail(env, "null indices array", -1);
return NULL;
}
if (SafeArrayGetDim(psa) != env->GetArrayLength(indices)) {
ThrowComFail(env, "safearray and indices array have different dimensions", -1);
return NULL;
}
// prepare a new return value
jclass variantClass = env->FindClass("com/jacob/com/Variant");
jmethodID variantCons =
env->GetMethodID(variantClass, "<init>", "()V");
// construct a variant to return
jobject newVariant = env->NewObject(variantClass, variantCons);
// get the VARIANT from the newVariant
VARIANT *v = extractVariant(env, newVariant);
if (vt == VT_VARIANT) {
SafeArrayGetElement(psa, jIndices, v);
} else if (vt == VT_DISPATCH || vt == VT_UNKNOWN) {
IDispatch *disp;
SafeArrayGetElement(psa, jIndices, (void *)&disp);
VariantClear(v); // whatever was there before
V_VT(v) = VT_DISPATCH;
V_DISPATCH(v) = disp;
// I am handing the pointer to COM
disp->AddRef();
} else {
ThrowComFail(env, "safearray type is not variant/dispatch", -1);
}
return newVariant;
}
/*
* Class: com_jacob_com_SafeArray
* Method: setVariant
* Signature: ([ILcom/jacob/com/Variant;)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setVariant___3ILcom_jacob_com_Variant_2
(JNIEnv *env, jobject _this, jintArray indices, jobject s)
{
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
// ??? Not sure if this is correct type for call to SafeArrayGetElement()
jint *jIndices = env->GetIntArrayElements(indices, NULL);
if (!jIndices) {
ThrowComFail(env, "null indices array", -1);
return;
}
if (SafeArrayGetDim(sa) != env->GetArrayLength(indices)) {
ThrowComFail(env, "safearray and indices array have different dimensions", -1);
return;
}
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
if (vt == VT_VARIANT) {
VARIANT *v = extractVariant(env, s);
SafeArrayPutElement(sa, jIndices, v);
} else if (vt == VT_DISPATCH || vt == VT_UNKNOWN) {
VARIANT *v = extractVariant(env, s);
if (V_VT(v) != VT_DISPATCH) {
ThrowComFail(env, "variant is not dispatch", -1);
return;
}
IDispatch *disp = V_DISPATCH(v);
SafeArrayPutElement(sa, jIndices, disp);
} else {
ThrowComFail(env, "safearray type is not variant/dispatch", -1);
}
}
/*
* Class: com_jacob_com_SafeArray
* Method: getChar
* Signature: ([I)C
*/
JNIEXPORT jchar JNICALL Java_com_jacob_com_SafeArray_getChar___3I
(JNIEnv *env, jobject _this, jintArray indices)
{
GETNDCODE(VT_UI2, V_UI2, jchar)
}
/*
* Class: com_jacob_com_SafeArray
* Method: setChar
* Signature: ([IC)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setChar___3IC
(JNIEnv *env, jobject _this, jintArray indices, jchar c)
{
SETNDCODE(VT_UI2, V_UI2);
}
/*
* Class: com_jacob_com_SafeArray
* Method: getInt
* Signature: ([I)I
*/
JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getInt___3I
(JNIEnv *env, jobject _this, jintArray indices)
{
GETNDCODE(VT_I4, V_I4, jint)
}
/*
* Class: com_jacob_com_SafeArray
* Method: setInt
* Signature: ([II)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setInt___3II
(JNIEnv *env, jobject _this, jintArray indices, jint c)
{
SETNDCODE(VT_I4, V_I4);
}
/*
* Class: com_jacob_com_SafeArray
* Method: getShort
* Signature: ([I)S
*/
JNIEXPORT jshort JNICALL Java_com_jacob_com_SafeArray_getShort___3I
(JNIEnv *env, jobject _this, jintArray indices)
{
GETNDCODE(VT_I2, V_I2, jshort)
}
/*
* Class: com_jacob_com_SafeArray
* Method: setShort
* Signature: ([IS)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setShort___3IS
(JNIEnv *env, jobject _this, jintArray indices, jshort c)
{
SETNDCODE(VT_I2, V_I2);
}
/*
* Class: com_jacob_com_SafeArray
* Method: getDouble
* Signature: ([I)D
*/
JNIEXPORT jdouble JNICALL Java_com_jacob_com_SafeArray_getDouble___3I
(JNIEnv *env, jobject _this, jintArray indices)
{
GETNDCODE(VT_R8, V_R8, jdouble)
}
/*
* Class: com_jacob_com_SafeArray
* Method: setDouble
* Signature: ([ID)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setDouble___3ID
(JNIEnv *env, jobject _this, jintArray indices, jdouble c)
{
SETNDCODE(VT_R8, V_R8);
}
/*
* Class: com_jacob_com_SafeArray
* Method: getString
* Signature: ([I)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_com_jacob_com_SafeArray_getString___3I
(JNIEnv *env, jobject _this, jintArray indices)
{
SAFEARRAY *psa = extractSA(env, _this);
if (!psa) {
ThrowComFail(env, "safearray object corrupted", -1); \
return NULL;
}
// ??? Not sure if this is correct type for call to SafeArrayGetElement()
jint *jIndices = env->GetIntArrayElements(indices, NULL);
if (!jIndices) {
ThrowComFail(env, "null indices array", -1);
return NULL;
}
if (SafeArrayGetDim(psa) != env->GetArrayLength(indices)) {
ThrowComFail(env, "safearray and indices array have different dimensions", -1);
return NULL;
}
VARTYPE vt;
SafeArrayGetVartype(psa, &vt);
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
SafeArrayGetElement(psa, jIndices, &v);
if (FAILED(VariantChangeType(&v, &v, 0, VT_BSTR))) {
return NULL;
}
BSTR bs = V_BSTR(&v);
jstring js = env->NewString((jchar*)bs, SysStringLen(bs)); // SR cast SF 1689061
return js;
} else if (vt == VT_BSTR) {
BSTR bs = NULL;
SafeArrayGetElement(psa, jIndices, &bs);
jstring js = env->NewString((jchar*)bs, SysStringLen(bs)); // SR cast SF 1689061
return js;
}
ThrowComFail(env, "safearray cannot get string", 0);
return NULL;
}
/*
* Class: com_jacob_com_SafeArray
* Method: setString
* Signature: ([ILjava/lang/String;)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setString___3ILjava_lang_String_2
(JNIEnv *env, jobject _this, jintArray indices, jstring s)
{
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
// ??? Not sure if this is correct type for call to SafeArrayGetElement()
jint *jIndices = env->GetIntArrayElements(indices, NULL);
if (!jIndices) {
ThrowComFail(env, "null indices array", -1);
return;
}
if (SafeArrayGetDim(sa) != env->GetArrayLength(indices)) {
ThrowComFail(env, "safearray and indices array have different dimensions", -1);
return;
}
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
const char *str = env->GetStringUTFChars(s, NULL);
CComBSTR bs(str);
V_VT(&v) = VT_BSTR;
V_BSTR(&v) = bs.Copy();
SafeArrayPutElement(sa, jIndices,&v);
env->ReleaseStringUTFChars(s, str);
VariantClear(&v);
} else if (vt == VT_BSTR) {
const char *str = env->GetStringUTFChars(s, NULL);
CComBSTR bs(str);
SafeArrayPutElement(sa, jIndices,bs.Detach());
env->ReleaseStringUTFChars(s, str);
} else {
ThrowComFail(env, "safearray cannot set string", 0);
}
}
/*
* Class: com_jacob_com_SafeArray
* Method: getByte
* Signature: ([I)B
*/
JNIEXPORT jbyte JNICALL Java_com_jacob_com_SafeArray_getByte___3I
(JNIEnv *env, jobject _this, jintArray indices)
{
GETNDCODE(VT_UI1, V_UI1, jbyte)
}
/*
* Class: com_jacob_com_SafeArray
* Method: setByte
* Signature: ([IB)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setByte___3IB
(JNIEnv *env, jobject _this, jintArray indices, jbyte c)
{
SETNDCODE(VT_UI1, V_UI1);
}
/*
* Class: com_jacob_com_SafeArray
* Method: getFloat
* Signature: ([I)F
*/
JNIEXPORT jfloat JNICALL Java_com_jacob_com_SafeArray_getFloat___3I
(JNIEnv *env, jobject _this, jintArray indices)
{
GETNDCODE(VT_R4, V_R4, jfloat)
}
/*
* Class: com_jacob_com_SafeArray
* Method: setFloat
* Signature: ([IF)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setFloat___3IF
(JNIEnv *env, jobject _this, jintArray indices, jfloat c)
{
SETNDCODE(VT_R4, V_R4);
}
/*
* Class: com_jacob_com_SafeArray
* Method: getBoolean
* Signature: ([I)Z
*/
JNIEXPORT jboolean JNICALL Java_com_jacob_com_SafeArray_getBoolean___3I
(JNIEnv *env, jobject _this, jintArray indices)
{
// code is inline because of size mismatch
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return NULL;
}
// ??? Not sure if this is correct type for call to SafeArrayGetElement()
jint *jIndices = env->GetIntArrayElements(indices, NULL);
if (!jIndices) {
ThrowComFail(env, "null indices array", -1);
return NULL;
}
if (SafeArrayGetDim(sa) != env->GetArrayLength(indices)) {
ThrowComFail(env, "safearray and indices array have different dimensions", -1);
return NULL;
}
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
SafeArrayGetElement(sa, jIndices, (void*) &v);
if (FAILED(VariantChangeType(&v, &v, 0, VT_BOOL))) {
ThrowComFail(env, "safearray change type failed", -1);
return NULL;
}
jboolean jb = V_BOOL(&v) == VARIANT_TRUE ? JNI_TRUE: JNI_FALSE;
return jb;
} else if (vt == VT_BOOL) {
VARIANT_BOOL vb;
SafeArrayGetElement(sa, jIndices, (void*) &vb);
jboolean jb = vb == VARIANT_TRUE ? JNI_TRUE: JNI_FALSE;
return jb;
} else {
return NULL;
}
}
/*
* Class: com_jacob_com_SafeArray
* Method: setBoolean
* Signature: ([IZ)V
*/
JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setBoolean___3IZ
(JNIEnv *env, jobject _this, jintArray indices, jboolean c)
{
// code is inline because of size mismatch
SAFEARRAY *sa = extractSA(env, _this);
if (!sa) {
ThrowComFail(env, "safearray object corrupted", -1);
return;
}
// ??? Not sure if this is correct type for call to SafeArrayGetElement()
jint *jIndices = env->GetIntArrayElements(indices, NULL);
if (!jIndices) {
ThrowComFail(env, "null indices array", -1);
return;
}
if (SafeArrayGetDim(sa) != env->GetArrayLength(indices)) {
ThrowComFail(env, "safearray and indices array have different dimensions", -1);
return;
}
VARTYPE vt;
SafeArrayGetVartype(sa, &vt);
if (vt == VT_VARIANT) {
VARIANT v;
VariantInit(&v);
V_VT(&v) = VT_BOOL;
V_BOOL(&v) = c == JNI_TRUE ? VARIANT_TRUE : VARIANT_FALSE;
SafeArrayPutElement(sa,jIndices,&v);
} else if (vt == VT_BOOL) {
VARIANT_BOOL vb = c == JNI_TRUE ? VARIANT_TRUE : VARIANT_FALSE;
SafeArrayPutElement(sa,jIndices,&vb);
} else {
ThrowComFail(env, "safearray type mismatch", -1);
}
}
}
Reference in New Issue View Git Blame Copy Permalink