654 lines
15 KiB
C
654 lines
15 KiB
C
/*
|
|
* @(#) $(JCGO)/native/jcgojnu.c --
|
|
* a part of the JCGO native layer library (native layer API implementation).
|
|
**
|
|
* Project: JCGO (http://www.ivmaisoft.com/jcgo/)
|
|
* Copyright (C) 2001-2013 Ivan Maidanski <ivmai@mail.ru>
|
|
* All rights reserved.
|
|
*/
|
|
|
|
/*
|
|
* Used control macros: JCGO_DOWCSTOMBS, JCGO_HUGEARR, JCGO_NOJNI,
|
|
* JCGO_SYSWCHAR, JCGO_THREADS, JCGO_UTFWCTOMB, JCGO_WMAIN.
|
|
* Macros for tuning: JNUBIGEXPORT.
|
|
*/
|
|
|
|
/*
|
|
* This is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
* any later version.
|
|
**
|
|
* This software 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 (GPL) for more details.
|
|
**
|
|
* Linking this library statically or dynamically with other modules is
|
|
* making a combined work based on this library. Thus, the terms and
|
|
* conditions of the GNU General Public License cover the whole
|
|
* combination.
|
|
**
|
|
* As a special exception, the copyright holders of this library give you
|
|
* permission to link this library with independent modules to produce an
|
|
* executable, regardless of the license terms of these independent
|
|
* modules, and to copy and distribute the resulting executable under
|
|
* terms of your choice, provided that you also meet, for each linked
|
|
* independent module, the terms and conditions of the license of that
|
|
* module. An independent module is a module which is not derived from
|
|
* or based on this library. If you modify this library, you may extend
|
|
* this exception to your version of the library, but you are not
|
|
* obligated to do so. If you do not wish to do so, delete this
|
|
* exception statement from your version.
|
|
*/
|
|
|
|
#define JCGO_BUILDING_JNU
|
|
#ifdef JCGO_VER
|
|
#include "jcgojnu.h"
|
|
#else
|
|
#include "jcgojnu.h"
|
|
#ifdef JCGO_NOJNI
|
|
#ifndef JCGO_SEPARATED
|
|
#define JCGO_SEPARATED
|
|
#endif
|
|
#include "jcgortl.h"
|
|
jint *JNICALL jcgo_jnuStringLengthPtr( jstring str );
|
|
jchar *JNICALL jcgo_jnuStringChars( jstring str, int *pisbytes );
|
|
jstring JNICALL jcgo_jnuStringCreate( JNIEnv *pJniEnv, jint len );
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef JCGO_VER
|
|
|
|
#ifndef JCGO_UTFWCTOMB
|
|
|
|
/* #include <stdlib.h> */
|
|
/* const int MB_CUR_MAX; */
|
|
|
|
#ifdef JCGO_DOWCSTOMBS
|
|
/* #include <stdlib.h> */
|
|
/* size_t mbstowcs(wchar_t *, const char *, size_t); */
|
|
/* size_t wcstombs(char *, const wchar_t *, size_t); */
|
|
#else
|
|
/* #include <stdlib.h> */
|
|
/* int mbtowc(wchar_t *, const char *, size_t); */
|
|
/* int wctomb(char *, wchar_t); */
|
|
#endif
|
|
|
|
#ifndef _LIMITS_H
|
|
#include <limits.h>
|
|
#endif
|
|
|
|
#ifndef MB_LEN_MAX
|
|
#define MB_LEN_MAX 6
|
|
#endif
|
|
|
|
#endif /* !JCGO_UTFWCTOMB */
|
|
|
|
#ifndef JNUBIGEXPORT
|
|
#define JNUBIGEXPORT JNIEXPORT
|
|
#endif
|
|
|
|
#ifndef JCGO_JNUMSG_BADARG
|
|
#define JCGO_JNUMSG_BADARG "" /* in 'UTF-8' encoding */
|
|
#endif
|
|
|
|
#ifndef JCGO_NOJNI
|
|
#ifndef JCGO_ALLOCSIZE_T
|
|
#ifdef JCGO_HUGEARR
|
|
#define JCGO_ALLOCSIZE_T unsigned long
|
|
#else
|
|
#define JCGO_ALLOCSIZE_T unsigned
|
|
#endif
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef JCGO_HPTR_MOD
|
|
#ifdef JCGO_HUGEARR
|
|
#define JCGO_HPTR_MOD __huge
|
|
#else
|
|
#define JCGO_HPTR_MOD /* empty */
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef JCGO_JNUNEWSTRING_WBUFSIZE
|
|
#define JCGO_JNUNEWSTRING_WBUFSIZE 128
|
|
#endif
|
|
|
|
#ifdef JCGO_NOJNI
|
|
JNIEXPORT
|
|
#else
|
|
JNUBIGEXPORT
|
|
#endif
|
|
jbyte *JNICALL
|
|
jcgo_JnuGetByteArrayElemsRegion( JNIEnv *pJniEnv, jbyteArray arr, jint offset,
|
|
jint len )
|
|
{
|
|
#ifdef JCGO_NOJNI
|
|
JCGO_UNUSED_VAR(pJniEnv);
|
|
JCGO_UNUSED_VAR(len);
|
|
return (jbyte *)&JCGO_ARR_INTERNALACC(jbyte, (jbyteArr)arr, offset);
|
|
#else
|
|
jbyte *bytes = (*pJniEnv)->GetByteArrayElements(pJniEnv, arr, NULL);
|
|
if (bytes == NULL)
|
|
return NULL;
|
|
if ((offset | len) < 0 ||
|
|
(*pJniEnv)->GetArrayLength(pJniEnv, (jarray)arr) - offset < len)
|
|
{
|
|
(*pJniEnv)->FatalError(pJniEnv, JCGO_JNUMSG_BADARG);
|
|
return NULL;
|
|
}
|
|
return (jbyte *)((jbyte JCGO_HPTR_MOD *)bytes + (JCGO_ALLOCSIZE_T)offset);
|
|
#endif
|
|
}
|
|
|
|
JNIEXPORT void JNICALL
|
|
jcgo_JnuReleaseByteArrayElemsRegion( JNIEnv *pJniEnv, jbyteArray arr,
|
|
jbyte *bytes, jint offset )
|
|
{
|
|
#ifdef JCGO_NOJNI
|
|
JCGO_UNUSED_VAR(pJniEnv);
|
|
JCGO_UNUSED_VAR(arr);
|
|
JCGO_UNUSED_VAR(bytes);
|
|
JCGO_UNUSED_VAR(offset);
|
|
#else
|
|
(*pJniEnv)->ReleaseByteArrayElements(pJniEnv, arr,
|
|
(jbyte *)((jbyte JCGO_HPTR_MOD *)bytes - (JCGO_ALLOCSIZE_T)offset), 0);
|
|
#endif
|
|
}
|
|
|
|
JNIEXPORT jint JNICALL
|
|
jcgo_JnuGetIntArrayElement( JNIEnv *pJniEnv, jintArray arr, jint index )
|
|
{
|
|
#ifdef JCGO_NOJNI
|
|
JCGO_UNUSED_VAR(pJniEnv);
|
|
return JCGO_ARR_INTERNALACC(jint, (jintArr)arr, index);
|
|
#else
|
|
jint value = 0;
|
|
(*pJniEnv)->GetIntArrayRegion(pJniEnv, arr, (jsize)index, 1, &value);
|
|
return value;
|
|
#endif
|
|
}
|
|
|
|
JNIEXPORT void JNICALL
|
|
jcgo_JnuSetIntArrayElement( JNIEnv *pJniEnv, jintArray arr, jint index,
|
|
jint value )
|
|
{
|
|
#ifdef JCGO_NOJNI
|
|
JCGO_UNUSED_VAR(pJniEnv);
|
|
JCGO_ARR_INTERNALACC(jint, (jintArr)arr, index) = value;
|
|
#else
|
|
(*pJniEnv)->SetIntArrayRegion(pJniEnv, arr, (jsize)index, 1, &value);
|
|
#endif
|
|
}
|
|
|
|
JNIEXPORT void JNICALL
|
|
jcgo_JnuSetLongArrayElement( JNIEnv *pJniEnv, jlongArray arr, jint index,
|
|
jlong value )
|
|
{
|
|
#ifdef JCGO_NOJNI
|
|
JCGO_UNUSED_VAR(pJniEnv);
|
|
JCGO_ARR_INTERNALACC(jlong, (jlongArr)arr, index) = value;
|
|
#else
|
|
(*pJniEnv)->SetLongArrayRegion(pJniEnv, arr, (jsize)index, 1, &value);
|
|
#endif
|
|
}
|
|
|
|
JNUBIGEXPORT unsigned JNICALL
|
|
jcgo_JnuStringSizeOfPlatform( JNIEnv *pJniEnv, jstring str )
|
|
{
|
|
unsigned len = 0;
|
|
#ifdef JCGO_NOJNI
|
|
jint count = *jcgo_jnuStringLengthPtr(str);
|
|
JCGO_UNUSED_VAR(pJniEnv);
|
|
#else
|
|
jint count = (jint)(*pJniEnv)->GetStringLength(pJniEnv, str);
|
|
#endif
|
|
if (count > 0)
|
|
{
|
|
#ifdef JCGO_UTFWCTOMB
|
|
len = count <= (jint)(((((unsigned)-1) >> 1) - 16) / 3) ?
|
|
(unsigned)count * 3 : (((unsigned)-1) >> 1) - (unsigned)16;
|
|
#else
|
|
len = (unsigned)count;
|
|
if (count > (jint)((((unsigned)-1) >> 1) - 16))
|
|
len = (((unsigned)-1) >> 1) - (unsigned)16;
|
|
#ifdef MB_CUR_MAX
|
|
count = (jint)MB_CUR_MAX;
|
|
if (count != 1)
|
|
#endif
|
|
{
|
|
#ifdef MB_CUR_MAX
|
|
if ((unsigned)count < (unsigned)MB_LEN_MAX &&
|
|
*(volatile jint *)&count != 0)
|
|
len = ((((unsigned)-1) >> 1) - (unsigned)16) / (unsigned)count >= len ?
|
|
(unsigned)count * len : (((unsigned)-1) >> 1) - (unsigned)16;
|
|
else
|
|
#endif
|
|
{
|
|
len = len <= ((((unsigned)-1) >> 1) - (unsigned)16) /
|
|
(unsigned)MB_LEN_MAX ? len * (unsigned)MB_LEN_MAX :
|
|
(((unsigned)-1) >> 1) - (unsigned)16;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
return len + 1;
|
|
}
|
|
|
|
JNUBIGEXPORT int JNICALL
|
|
jcgo_JnuStringToPlatformChars( JNIEnv *pJniEnv, jstring str, char *cbuf,
|
|
unsigned size )
|
|
{
|
|
int cnt;
|
|
int i;
|
|
unsigned pos;
|
|
unsigned len;
|
|
int noerr = -1;
|
|
jint count;
|
|
CONST jchar JCGO_HPTR_MOD *chars;
|
|
#ifdef JCGO_NOJNI
|
|
int isbytes;
|
|
#endif
|
|
#ifdef JCGO_UTFWCTOMB
|
|
jchar wch;
|
|
#else
|
|
int res;
|
|
#ifdef JCGO_DOWCSTOMBS
|
|
wchar_t wbuf[2];
|
|
#else
|
|
int j;
|
|
char mbbuf[MB_LEN_MAX];
|
|
#endif
|
|
#endif
|
|
if (cbuf != NULL && size)
|
|
{
|
|
#ifdef JCGO_NOJNI
|
|
JCGO_UNUSED_VAR(pJniEnv);
|
|
chars = jcgo_jnuStringChars(str, &isbytes);
|
|
count = *jcgo_jnuStringLengthPtr(str);
|
|
#else
|
|
chars = (*pJniEnv)->GetStringChars(pJniEnv, str, NULL);
|
|
if (chars == NULL)
|
|
return noerr;
|
|
count = (jint)(*pJniEnv)->GetStringLength(pJniEnv, str);
|
|
#endif
|
|
len = (((unsigned)-1) >> 1) - (unsigned)16;
|
|
pos = 0;
|
|
noerr = 1;
|
|
if (size <= len)
|
|
len = size - 1;
|
|
cnt = (int)len;
|
|
if ((jint)cnt > count)
|
|
cnt = (int)count;
|
|
#ifndef JCGO_UTFWCTOMB
|
|
#ifdef JCGO_DOWCSTOMBS
|
|
wbuf[1] = (wchar_t)0;
|
|
#else
|
|
*(volatile char *)&mbbuf[0] = (char)wctomb(NULL, (wchar_t)0);
|
|
#endif
|
|
#endif
|
|
for (i = 0; i < cnt; i++)
|
|
{
|
|
#ifdef JCGO_UTFWCTOMB
|
|
#ifdef JCGO_NOJNI
|
|
wch = isbytes ? (unsigned char)(*((volatile jbyte JCGO_HPTR_MOD *)chars +
|
|
(unsigned)i)) : *(chars + (unsigned)i);
|
|
#else
|
|
wch = *(chars + (unsigned)i);
|
|
#endif
|
|
if (wch < 0x80 && wch)
|
|
{
|
|
if (pos >= len)
|
|
break;
|
|
cbuf[pos] = (char)wch;
|
|
}
|
|
else
|
|
{
|
|
if (wch < 0x800)
|
|
{
|
|
if (pos + 1 >= len)
|
|
break;
|
|
cbuf[pos] = (char)((wch >> 6) | 0xc0);
|
|
}
|
|
else
|
|
{
|
|
if (pos + 2 >= len)
|
|
break;
|
|
cbuf[pos] = (char)((wch >> 12) | 0xe0);
|
|
cbuf[pos + 1] = (char)(((wch >> 6) & 0x3f) | 0x80);
|
|
pos++;
|
|
}
|
|
cbuf[++pos] = (char)((wch & 0x3f) | 0x80);
|
|
}
|
|
pos++;
|
|
#else
|
|
#ifdef JCGO_DOWCSTOMBS
|
|
#ifdef JCGO_NOJNI
|
|
wbuf[0] = (wchar_t)(isbytes ?
|
|
(unsigned char)(*((volatile jbyte JCGO_HPTR_MOD *)chars +
|
|
(unsigned)i)) : *(chars + (unsigned)i));
|
|
#else
|
|
wbuf[0] = (wchar_t)(*(chars + (unsigned)i));
|
|
#endif
|
|
res = (int)wcstombs(&cbuf[pos], wbuf, len - pos);
|
|
#else
|
|
#ifdef JCGO_NOJNI
|
|
res = wctomb(len - pos < sizeof(mbbuf) ? mbbuf : &cbuf[pos],
|
|
(wchar_t)(isbytes ?
|
|
(unsigned char)(*((volatile jbyte JCGO_HPTR_MOD *)chars +
|
|
(unsigned)i)) : *(chars + (unsigned)i)));
|
|
#else
|
|
res = wctomb(len - pos < sizeof(mbbuf) ? mbbuf : &cbuf[pos],
|
|
(wchar_t)(*(chars + (unsigned)i)));
|
|
#endif
|
|
#endif
|
|
if (res > 0)
|
|
{
|
|
#ifndef JCGO_DOWCSTOMBS
|
|
if (len - pos < sizeof(mbbuf))
|
|
{
|
|
if (pos + (unsigned)res > len)
|
|
break;
|
|
for (j = 0; j < res; j++)
|
|
cbuf[pos + j] = mbbuf[j];
|
|
}
|
|
#endif
|
|
pos = (unsigned)res + pos;
|
|
}
|
|
else
|
|
{
|
|
if (pos >= len)
|
|
break;
|
|
if (res < 0)
|
|
{
|
|
noerr = 0;
|
|
cbuf[pos++] = '?';
|
|
}
|
|
else cbuf[pos++] = '\0';
|
|
}
|
|
#endif
|
|
}
|
|
#ifndef JCGO_NOJNI
|
|
(*pJniEnv)->ReleaseStringChars(pJniEnv, str, (CONST jchar *)chars);
|
|
#endif
|
|
if ((jint)i < count)
|
|
{
|
|
noerr = 0;
|
|
if (pos < len)
|
|
cbuf[pos++] = '?';
|
|
else
|
|
{
|
|
if (len)
|
|
cbuf[len - 1] = '?';
|
|
}
|
|
}
|
|
cbuf[pos] = '\0';
|
|
}
|
|
#ifndef JCGO_NOJNI
|
|
else (*pJniEnv)->FatalError(pJniEnv, JCGO_JNUMSG_BADARG);
|
|
#endif
|
|
return noerr;
|
|
}
|
|
|
|
JNUBIGEXPORT jstring JNICALL
|
|
jcgo_JnuNewStringPlatform( JNIEnv *pJniEnv, CONST char *cstr )
|
|
{
|
|
#ifdef JCGO_UTFWCTOMB
|
|
jchar wch;
|
|
char ch;
|
|
unsigned pos;
|
|
#else
|
|
#ifndef JCGO_DOWCSTOMBS
|
|
wchar_t wch;
|
|
int res;
|
|
unsigned pos;
|
|
#endif
|
|
#endif
|
|
unsigned len = 0;
|
|
int i = (int)(((unsigned)-1) >> 1) - 16;
|
|
jstring str = NULL;
|
|
jchar *chars;
|
|
#ifndef JCGO_NOJNI
|
|
jcharArray arr;
|
|
jchar buf[JCGO_JNUNEWSTRING_WBUFSIZE];
|
|
#endif
|
|
if (cstr != NULL)
|
|
{
|
|
while (*(cstr + len))
|
|
len++;
|
|
if (len >= (unsigned)i)
|
|
len = (unsigned)i;
|
|
#ifdef JCGO_NOJNI
|
|
str = jcgo_jnuStringCreate(pJniEnv, (jint)len);
|
|
chars = NULL;
|
|
if (str != NULL)
|
|
chars = jcgo_jnuStringChars(str, &i);
|
|
#else
|
|
arr = NULL;
|
|
chars = buf;
|
|
if (len > sizeof(buf) / sizeof(jchar))
|
|
{
|
|
arr = (*pJniEnv)->NewCharArray(pJniEnv, (jsize)len);
|
|
chars = NULL;
|
|
if (arr != NULL)
|
|
chars = (*pJniEnv)->GetCharArrayElements(pJniEnv, arr, NULL);
|
|
}
|
|
#endif
|
|
if (chars != NULL)
|
|
{
|
|
i = 0;
|
|
#ifdef JCGO_UTFWCTOMB
|
|
for (pos = 0; pos < len; pos++)
|
|
{
|
|
wch = (unsigned char)cstr[pos];
|
|
if (wch >= 0x80 && (wch > 0xef ||
|
|
((ch = cstr[++pos]) & 0xc0) != 0x80 || (wch < 0xe0 ?
|
|
(wch = (jchar)(((wch & 0x1f) << 6) | (ch & 0x3f))) < 0x80 && wch :
|
|
(wch = (jchar)((wch << 12) | ((jchar)(ch & 0x3f) << 6) |
|
|
(cstr[++pos] & 0x3f))) < 0x800 || (cstr[pos] & 0xc0) != 0x80)))
|
|
{
|
|
*chars = (jchar)0x3f; /*'?'*/
|
|
if (i <= 0)
|
|
i = 1;
|
|
break;
|
|
}
|
|
*(chars + (i++)) = wch;
|
|
}
|
|
#else
|
|
#ifdef JCGO_DOWCSTOMBS
|
|
if (len && (i = (int)mbstowcs(chars, cstr, len)) < 0)
|
|
{
|
|
*chars = (jchar)0x3f; /*'?'*/
|
|
for (i = 1; i < (int)len; i++)
|
|
if (!(*(chars + i)))
|
|
break;
|
|
}
|
|
#else
|
|
*(volatile wchar_t *)&wch = (wchar_t)mbtowc(&wch, NULL, 0);
|
|
for (pos = 0; pos < len; pos = (unsigned)res + pos)
|
|
{
|
|
if ((res = mbtowc(&wch, cstr + pos, len - pos + 1)) <= 0)
|
|
{
|
|
if (!res)
|
|
break;
|
|
if ((res = mbtowc(&wch, cstr + pos, 1)) <= 0)
|
|
{
|
|
if (!res)
|
|
break;
|
|
*chars = (jchar)0x3f; /*'?'*/
|
|
if (i <= 0)
|
|
i = 1;
|
|
break;
|
|
}
|
|
}
|
|
*(chars + (i++)) = (jchar)wch;
|
|
}
|
|
#endif
|
|
#endif
|
|
#ifdef JCGO_NOJNI
|
|
*jcgo_jnuStringLengthPtr(str) = i;
|
|
#else
|
|
str = (*pJniEnv)->NewString(pJniEnv, chars, (jsize)i);
|
|
if (arr != NULL)
|
|
(*pJniEnv)->ReleaseCharArrayElements(pJniEnv, arr, chars, 0);
|
|
#endif
|
|
}
|
|
#ifndef JCGO_NOJNI
|
|
if (arr != NULL)
|
|
(*pJniEnv)->DeleteLocalRef(pJniEnv, (jobject)arr);
|
|
#endif
|
|
}
|
|
#ifndef JCGO_NOJNI
|
|
else (*pJniEnv)->FatalError(pJniEnv, JCGO_JNUMSG_BADARG);
|
|
#endif
|
|
return str;
|
|
}
|
|
|
|
#ifdef JCGO_SYSWCHAR
|
|
|
|
JNIEXPORT unsigned JNICALL
|
|
jcgo_JnuStringSizeOfWide( JNIEnv *pJniEnv, jstring str )
|
|
{
|
|
#ifdef JCGO_NOJNI
|
|
jint count = *jcgo_jnuStringLengthPtr(str);
|
|
JCGO_UNUSED_VAR(pJniEnv);
|
|
#else
|
|
jint count = (jint)(*pJniEnv)->GetStringLength(pJniEnv, str);
|
|
#endif
|
|
return count > 0 ? (count < (jint)(((((unsigned)-1) >> 1) - 16) /
|
|
sizeof(wchar_t)) ? ((unsigned)count + 1) * sizeof(wchar_t) :
|
|
(((unsigned)-1) >> 1) + sizeof(wchar_t) - 16) : sizeof(wchar_t);
|
|
}
|
|
|
|
JNUBIGEXPORT int JNICALL
|
|
jcgo_JnuStringToWideChars( JNIEnv *pJniEnv, jstring str, wchar_t *wbuf,
|
|
unsigned size )
|
|
{
|
|
int cnt;
|
|
int i;
|
|
int noerr = -1;
|
|
jint count;
|
|
CONST jchar JCGO_HPTR_MOD *chars;
|
|
#ifdef JCGO_NOJNI
|
|
int isbytes;
|
|
#endif
|
|
if (wbuf != NULL && size >= sizeof(wchar_t))
|
|
{
|
|
#ifdef JCGO_NOJNI
|
|
JCGO_UNUSED_VAR(pJniEnv);
|
|
chars = jcgo_jnuStringChars(str, &isbytes);
|
|
count = *jcgo_jnuStringLengthPtr(str);
|
|
#else
|
|
chars = (*pJniEnv)->GetStringChars(pJniEnv, str, NULL);
|
|
if (chars == NULL)
|
|
return noerr;
|
|
count = (jint)(*pJniEnv)->GetStringLength(pJniEnv, str);
|
|
#endif
|
|
cnt = (int)(((unsigned)-1) >> 1) - 16;
|
|
if (size <= (unsigned)cnt)
|
|
cnt = (int)size;
|
|
cnt = (int)((unsigned)cnt / sizeof(wchar_t)) - 1;
|
|
noerr = 1;
|
|
if ((jint)cnt < count)
|
|
{
|
|
noerr = 0;
|
|
if (cnt)
|
|
wbuf[cnt - 1] = (wchar_t)0x3f; /*'?'*/
|
|
}
|
|
else cnt = (int)count;
|
|
#ifdef JCGO_NOJNI
|
|
if (isbytes)
|
|
{
|
|
for (i = 0; i < cnt; i++)
|
|
wbuf[i] = (wchar_t)((unsigned char)(
|
|
*((volatile jbyte JCGO_HPTR_MOD *)chars + i)));
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i < cnt; i++)
|
|
wbuf[i] = (wchar_t)(*(chars + i));
|
|
}
|
|
#else
|
|
for (i = 0; i < cnt; i++)
|
|
wbuf[i] = (wchar_t)(*(chars + i));
|
|
(*pJniEnv)->ReleaseStringChars(pJniEnv, str, (CONST jchar *)chars);
|
|
#endif
|
|
wbuf[cnt] = (wchar_t)0;
|
|
}
|
|
#ifndef JCGO_NOJNI
|
|
else (*pJniEnv)->FatalError(pJniEnv, JCGO_JNUMSG_BADARG);
|
|
#endif
|
|
return noerr;
|
|
}
|
|
|
|
#else /* JCGO_SYSWCHAR */
|
|
|
|
#ifndef JCGO_WMAIN
|
|
#define JCGO_EXCLUDE_NEWSTRINGWIDE
|
|
#endif
|
|
|
|
#endif /* ! JCGO_SYSWCHAR */
|
|
|
|
#ifndef JCGO_EXCLUDE_NEWSTRINGWIDE
|
|
|
|
JNUBIGEXPORT jstring JNICALL
|
|
jcgo_JnuNewStringWide( JNIEnv *pJniEnv, CONST wchar_t *wstr )
|
|
{
|
|
unsigned len = 0;
|
|
int i = (int)(((((unsigned)-1) >> 1) - 16) / sizeof(wchar_t));
|
|
jstring str = NULL;
|
|
jchar *chars;
|
|
#ifndef JCGO_NOJNI
|
|
jcharArray arr;
|
|
jchar buf[JCGO_JNUNEWSTRING_WBUFSIZE];
|
|
#endif
|
|
if (wstr != NULL)
|
|
{
|
|
while (*(wstr + len))
|
|
len++;
|
|
if (len >= (unsigned)i)
|
|
len = (unsigned)i;
|
|
#ifdef JCGO_NOJNI
|
|
str = jcgo_jnuStringCreate(pJniEnv, (jint)len);
|
|
chars = NULL;
|
|
if (str != NULL)
|
|
chars = jcgo_jnuStringChars(str, &i);
|
|
#else
|
|
arr = NULL;
|
|
chars = buf;
|
|
if (len > sizeof(buf) / sizeof(jchar))
|
|
{
|
|
arr = (*pJniEnv)->NewCharArray(pJniEnv, (jsize)len);
|
|
chars = NULL;
|
|
if (arr != NULL)
|
|
chars = (*pJniEnv)->GetCharArrayElements(pJniEnv, arr, NULL);
|
|
}
|
|
#endif
|
|
if (chars != NULL)
|
|
{
|
|
for (i = 0; i < (int)len; i++)
|
|
*(chars + i) = (jchar)(*(wstr + i));
|
|
#ifdef JCGO_NOJNI
|
|
*jcgo_jnuStringLengthPtr(str) = (int)len;
|
|
#else
|
|
str = (*pJniEnv)->NewString(pJniEnv, chars, (jsize)len);
|
|
if (arr != NULL)
|
|
(*pJniEnv)->ReleaseCharArrayElements(pJniEnv, arr, chars, 0);
|
|
#endif
|
|
}
|
|
#ifndef JCGO_NOJNI
|
|
if (arr != NULL)
|
|
(*pJniEnv)->DeleteLocalRef(pJniEnv, (jobject)arr);
|
|
#endif
|
|
}
|
|
#ifndef JCGO_NOJNI
|
|
else (*pJniEnv)->FatalError(pJniEnv, JCGO_JNUMSG_BADARG);
|
|
#endif
|
|
return str;
|
|
}
|
|
|
|
#endif /* ! JCGO_EXCLUDE_NEWSTRINGWIDE */
|
|
|
|
#endif
|