← Back to branch summary

~ubuntu-branches/debian/sid/swt-gtk/sid

« back to all changes in this revision

Viewing changes to c.c

  • Committer: Bazaar Package Importer
  • Author(s): Adrian Perez
  • Date: 2009-12-07 10:22:24 UTC
  • mfrom: (1.2.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20091207102224-70w2tax575mcks1w
Tags: 3.5.1-1
http://bugs.debian.org/558663
* New upstream release. Closes: #558663.
* debian/control: 
  - Add Vcs-* fields for Git repository.
  - Allow DM-Uploads.
  - Remove "Conflicts", package should live with eclipse.
* debian/rules: Fix default-java path around AWT_LIB_PATH.
* debian/copyright: Minor update.

Show diffs side-by-side

added added

removed removed

Lines of Context:
c.c
1
1
/*******************************************************************************
2
 
 * Copyright (c) 2000, 2007 IBM Corporation and others.
 
2
 * Copyright (c) 2000, 2008 IBM Corporation and others.
3
3
 * All rights reserved. This program and the accompanying materials
4
4
 * are made available under the terms of the Eclipse Public License v1.0
5
5
 * which accompanies this distribution, and is available at
29
29
 
30
30
#ifndef NO_free
31
31
JNIEXPORT void JNICALL C_NATIVE(free)
32
 
        (JNIEnv *env, jclass that, jint arg0)
 
32
        (JNIEnv *env, jclass that, jintLong arg0)
33
33
{
34
34
        C_NATIVE_ENTER(env, that, free_FUNC);
35
35
        free((void *)arg0);
38
38
#endif
39
39
 
40
40
#ifndef NO_getenv
41
 
JNIEXPORT jint JNICALL C_NATIVE(getenv)
 
41
JNIEXPORT jintLong JNICALL C_NATIVE(getenv)
42
42
        (JNIEnv *env, jclass that, jbyteArray arg0)
43
43
{
44
44
        jbyte *lparg0=NULL;
45
 
        jint rc = 0;
 
45
        jintLong rc = 0;
46
46
        C_NATIVE_ENTER(env, that, getenv_FUNC);
47
47
        if (arg0) if ((lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL)) == NULL) goto fail;
48
 
        rc = (jint)getenv((const char *)lparg0);
 
48
        rc = (jintLong)getenv((const char *)lparg0);
49
49
fail:
50
50
        if (arg0 && lparg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
51
51
        C_NATIVE_EXIT(env, that, getenv_FUNC);
54
54
#endif
55
55
 
56
56
#ifndef NO_malloc
57
 
JNIEXPORT jint JNICALL C_NATIVE(malloc)
58
 
        (JNIEnv *env, jclass that, jint arg0)
 
57
JNIEXPORT jintLong JNICALL C_NATIVE(malloc)
 
58
        (JNIEnv *env, jclass that, jintLong arg0)
59
59
{
60
 
        jint rc = 0;
 
60
        jintLong rc = 0;
61
61
        C_NATIVE_ENTER(env, that, malloc_FUNC);
62
 
        rc = (jint)malloc(arg0);
 
62
        rc = (jintLong)malloc(arg0);
63
63
        C_NATIVE_EXIT(env, that, malloc_FUNC);
64
64
        return rc;
65
65
}
66
66
#endif
67
67
 
68
 
#ifndef NO_memmove__III
69
 
JNIEXPORT void JNICALL C_NATIVE(memmove__III)
70
 
        (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
 
68
#if (!defined(NO_memmove__III) && !defined(JNI64)) || (!defined(NO_memmove__JJJ) && defined(JNI64))
 
69
#ifndef JNI64
 
70
JNIEXPORT void JNICALL C_NATIVE(memmove__III)(JNIEnv *env, jclass that, jintLong arg0, jintLong arg1, jintLong arg2)
 
71
#else
 
72
JNIEXPORT void JNICALL C_NATIVE(memmove__JJJ)(JNIEnv *env, jclass that, jintLong arg0, jintLong arg1, jintLong arg2)
 
73
#endif
71
74
{
 
75
#ifndef JNI64
72
76
        C_NATIVE_ENTER(env, that, memmove__III_FUNC);
 
77
#else
 
78
        C_NATIVE_ENTER(env, that, memmove__JJJ_FUNC);
 
79
#endif
73
80
        memmove((void *)arg0, (const void *)arg1, (size_t)arg2);
 
81
#ifndef JNI64
74
82
        C_NATIVE_EXIT(env, that, memmove__III_FUNC);
 
83
#else
 
84
        C_NATIVE_EXIT(env, that, memmove__JJJ_FUNC);
 
85
#endif
75
86
}
76
87
#endif
77
88
 
78
 
#ifndef NO_memmove__I_3BI
79
 
JNIEXPORT void JNICALL C_NATIVE(memmove__I_3BI)
80
 
        (JNIEnv *env, jclass that, jint arg0, jbyteArray arg1, jint arg2)
 
89
#if (!defined(NO_memmove__I_3BI) && !defined(JNI64)) || (!defined(NO_memmove__J_3BJ) && defined(JNI64))
 
90
#ifndef JNI64
 
91
JNIEXPORT void JNICALL C_NATIVE(memmove__I_3BI)(JNIEnv *env, jclass that, jintLong arg0, jbyteArray arg1, jintLong arg2)
 
92
#else
 
93
JNIEXPORT void JNICALL C_NATIVE(memmove__J_3BJ)(JNIEnv *env, jclass that, jintLong arg0, jbyteArray arg1, jintLong arg2)
 
94
#endif
81
95
{
82
96
        jbyte *lparg1=NULL;
 
97
#ifndef JNI64
83
98
        C_NATIVE_ENTER(env, that, memmove__I_3BI_FUNC);
 
99
#else
 
100
        C_NATIVE_ENTER(env, that, memmove__J_3BJ_FUNC);
 
101
#endif
84
102
#ifdef JNI_VERSION_1_2
85
103
        if (IS_JNI_1_2) {
86
104
                if (arg1) if ((lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL)) == NULL) goto fail;
99
117
        {
100
118
                if (arg1 && lparg1) (*env)->ReleaseByteArrayElements(env, arg1, lparg1, JNI_ABORT);
101
119
        }
 
120
#ifndef JNI64
102
121
        C_NATIVE_EXIT(env, that, memmove__I_3BI_FUNC);
 
122
#else
 
123
        C_NATIVE_EXIT(env, that, memmove__J_3BJ_FUNC);
 
124
#endif
103
125
}
104
126
#endif
105
127
 
106
 
#ifndef NO_memmove__I_3CI
107
 
JNIEXPORT void JNICALL C_NATIVE(memmove__I_3CI)
108
 
        (JNIEnv *env, jclass that, jint arg0, jcharArray arg1, jint arg2)
 
128
#if (!defined(NO_memmove__I_3CI) && !defined(JNI64)) || (!defined(NO_memmove__J_3CJ) && defined(JNI64))
 
129
#ifndef JNI64
 
130
JNIEXPORT void JNICALL C_NATIVE(memmove__I_3CI)(JNIEnv *env, jclass that, jintLong arg0, jcharArray arg1, jintLong arg2)
 
131
#else
 
132
JNIEXPORT void JNICALL C_NATIVE(memmove__J_3CJ)(JNIEnv *env, jclass that, jintLong arg0, jcharArray arg1, jintLong arg2)
 
133
#endif
109
134
{
110
135
        jchar *lparg1=NULL;
 
136
#ifndef JNI64
111
137
        C_NATIVE_ENTER(env, that, memmove__I_3CI_FUNC);
 
138
#else
 
139
        C_NATIVE_ENTER(env, that, memmove__J_3CJ_FUNC);
 
140
#endif
112
141
#ifdef JNI_VERSION_1_2
113
142
        if (IS_JNI_1_2) {
114
143
                if (arg1) if ((lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL)) == NULL) goto fail;
127
156
        {
128
157
                if (arg1 && lparg1) (*env)->ReleaseCharArrayElements(env, arg1, lparg1, JNI_ABORT);
129
158
        }
 
159
#ifndef JNI64
130
160
        C_NATIVE_EXIT(env, that, memmove__I_3CI_FUNC);
 
161
#else
 
162
        C_NATIVE_EXIT(env, that, memmove__J_3CJ_FUNC);
 
163
#endif
131
164
}
132
165
#endif
133
166
 
134
 
#ifndef NO_memmove__I_3DI
135
 
JNIEXPORT void JNICALL C_NATIVE(memmove__I_3DI)
136
 
        (JNIEnv *env, jclass that, jint arg0, jdoubleArray arg1, jint arg2)
 
167
#if (!defined(NO_memmove__I_3DI) && !defined(JNI64)) || (!defined(NO_memmove__J_3DJ) && defined(JNI64))
 
168
#ifndef JNI64
 
169
JNIEXPORT void JNICALL C_NATIVE(memmove__I_3DI)(JNIEnv *env, jclass that, jintLong arg0, jdoubleArray arg1, jintLong arg2)
 
170
#else
 
171
JNIEXPORT void JNICALL C_NATIVE(memmove__J_3DJ)(JNIEnv *env, jclass that, jintLong arg0, jdoubleArray arg1, jintLong arg2)
 
172
#endif
137
173
{
138
174
        jdouble *lparg1=NULL;
 
175
#ifndef JNI64
139
176
        C_NATIVE_ENTER(env, that, memmove__I_3DI_FUNC);
 
177
#else
 
178
        C_NATIVE_ENTER(env, that, memmove__J_3DJ_FUNC);
 
179
#endif
140
180
#ifdef JNI_VERSION_1_2
141
181
        if (IS_JNI_1_2) {
142
182
                if (arg1) if ((lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL)) == NULL) goto fail;
155
195
        {
156
196
                if (arg1 && lparg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, JNI_ABORT);
157
197
        }
 
198
#ifndef JNI64
158
199
        C_NATIVE_EXIT(env, that, memmove__I_3DI_FUNC);
 
200
#else
 
201
        C_NATIVE_EXIT(env, that, memmove__J_3DJ_FUNC);
 
202
#endif
159
203
}
160
204
#endif
161
205
 
162
 
#ifndef NO_memmove__I_3FI
163
 
JNIEXPORT void JNICALL C_NATIVE(memmove__I_3FI)
164
 
        (JNIEnv *env, jclass that, jint arg0, jfloatArray arg1, jint arg2)
 
206
#if (!defined(NO_memmove__I_3FI) && !defined(JNI64)) || (!defined(NO_memmove__J_3FJ) && defined(JNI64))
 
207
#ifndef JNI64
 
208
JNIEXPORT void JNICALL C_NATIVE(memmove__I_3FI)(JNIEnv *env, jclass that, jintLong arg0, jfloatArray arg1, jintLong arg2)
 
209
#else
 
210
JNIEXPORT void JNICALL C_NATIVE(memmove__J_3FJ)(JNIEnv *env, jclass that, jintLong arg0, jfloatArray arg1, jintLong arg2)
 
211
#endif
165
212
{
166
213
        jfloat *lparg1=NULL;
 
214
#ifndef JNI64
167
215
        C_NATIVE_ENTER(env, that, memmove__I_3FI_FUNC);
 
216
#else
 
217
        C_NATIVE_ENTER(env, that, memmove__J_3FJ_FUNC);
 
218
#endif
168
219
#ifdef JNI_VERSION_1_2
169
220
        if (IS_JNI_1_2) {
170
221
                if (arg1) if ((lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL)) == NULL) goto fail;
183
234
        {
184
235
                if (arg1 && lparg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, JNI_ABORT);
185
236
        }
 
237
#ifndef JNI64
186
238
        C_NATIVE_EXIT(env, that, memmove__I_3FI_FUNC);
 
239
#else
 
240
        C_NATIVE_EXIT(env, that, memmove__J_3FJ_FUNC);
 
241
#endif
187
242
}
188
243
#endif
189
244
 
190
 
#ifndef NO_memmove__I_3II
191
 
JNIEXPORT void JNICALL C_NATIVE(memmove__I_3II)
192
 
        (JNIEnv *env, jclass that, jint arg0, jintArray arg1, jint arg2)
 
245
#if (!defined(NO_memmove__I_3II) && !defined(JNI64)) || (!defined(NO_memmove__J_3IJ) && defined(JNI64))
 
246
#ifndef JNI64
 
247
JNIEXPORT void JNICALL C_NATIVE(memmove__I_3II)(JNIEnv *env, jclass that, jintLong arg0, jintArray arg1, jintLong arg2)
 
248
#else
 
249
JNIEXPORT void JNICALL C_NATIVE(memmove__J_3IJ)(JNIEnv *env, jclass that, jintLong arg0, jintArray arg1, jintLong arg2)
 
250
#endif
193
251
{
194
252
        jint *lparg1=NULL;
 
253
#ifndef JNI64
195
254
        C_NATIVE_ENTER(env, that, memmove__I_3II_FUNC);
 
255
#else
 
256
        C_NATIVE_ENTER(env, that, memmove__J_3IJ_FUNC);
 
257
#endif
196
258
#ifdef JNI_VERSION_1_2
197
259
        if (IS_JNI_1_2) {
198
260
                if (arg1) if ((lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL)) == NULL) goto fail;
211
273
        {
212
274
                if (arg1 && lparg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, JNI_ABORT);
213
275
        }
 
276
#ifndef JNI64
214
277
        C_NATIVE_EXIT(env, that, memmove__I_3II_FUNC);
 
278
#else
 
279
        C_NATIVE_EXIT(env, that, memmove__J_3IJ_FUNC);
 
280
#endif
215
281
}
216
282
#endif
217
283
 
218
 
#ifndef NO_memmove__I_3JI
219
 
JNIEXPORT void JNICALL C_NATIVE(memmove__I_3JI)
220
 
        (JNIEnv *env, jclass that, jint arg0, jlongArray arg1, jint arg2)
 
284
#if (!defined(NO_memmove__I_3JI) && !defined(JNI64)) || (!defined(NO_memmove__J_3JJ) && defined(JNI64))
 
285
#ifndef JNI64
 
286
JNIEXPORT void JNICALL C_NATIVE(memmove__I_3JI)(JNIEnv *env, jclass that, jintLong arg0, jlongArray arg1, jintLong arg2)
 
287
#else
 
288
JNIEXPORT void JNICALL C_NATIVE(memmove__J_3JJ)(JNIEnv *env, jclass that, jintLong arg0, jlongArray arg1, jintLong arg2)
 
289
#endif
221
290
{
222
291
        jlong *lparg1=NULL;
 
292
#ifndef JNI64
223
293
        C_NATIVE_ENTER(env, that, memmove__I_3JI_FUNC);
 
294
#else
 
295
        C_NATIVE_ENTER(env, that, memmove__J_3JJ_FUNC);
 
296
#endif
224
297
#ifdef JNI_VERSION_1_2
225
298
        if (IS_JNI_1_2) {
226
299
                if (arg1) if ((lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL)) == NULL) goto fail;
239
312
        {
240
313
                if (arg1 && lparg1) (*env)->ReleaseLongArrayElements(env, arg1, lparg1, JNI_ABORT);
241
314
        }
 
315
#ifndef JNI64
242
316
        C_NATIVE_EXIT(env, that, memmove__I_3JI_FUNC);
 
317
#else
 
318
        C_NATIVE_EXIT(env, that, memmove__J_3JJ_FUNC);
 
319
#endif
243
320
}
244
321
#endif
245
322
 
246
 
#ifndef NO_memmove__I_3SI
247
 
JNIEXPORT void JNICALL C_NATIVE(memmove__I_3SI)
248
 
        (JNIEnv *env, jclass that, jint arg0, jshortArray arg1, jint arg2)
 
323
#if (!defined(NO_memmove__I_3SI) && !defined(JNI64)) || (!defined(NO_memmove__J_3SJ) && defined(JNI64))
 
324
#ifndef JNI64
 
325
JNIEXPORT void JNICALL C_NATIVE(memmove__I_3SI)(JNIEnv *env, jclass that, jintLong arg0, jshortArray arg1, jintLong arg2)
 
326
#else
 
327
JNIEXPORT void JNICALL C_NATIVE(memmove__J_3SJ)(JNIEnv *env, jclass that, jintLong arg0, jshortArray arg1, jintLong arg2)
 
328
#endif
249
329
{
250
330
        jshort *lparg1=NULL;
 
331
#ifndef JNI64
251
332
        C_NATIVE_ENTER(env, that, memmove__I_3SI_FUNC);
 
333
#else
 
334
        C_NATIVE_ENTER(env, that, memmove__J_3SJ_FUNC);
 
335
#endif
252
336
#ifdef JNI_VERSION_1_2
253
337
        if (IS_JNI_1_2) {
254
338
                if (arg1) if ((lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL)) == NULL) goto fail;
267
351
        {
268
352
                if (arg1 && lparg1) (*env)->ReleaseShortArrayElements(env, arg1, lparg1, JNI_ABORT);
269
353
        }
 
354
#ifndef JNI64
270
355
        C_NATIVE_EXIT(env, that, memmove__I_3SI_FUNC);
 
356
#else
 
357
        C_NATIVE_EXIT(env, that, memmove__J_3SJ_FUNC);
 
358
#endif
271
359
}
272
360
#endif
273
361
 
274
 
#ifndef NO_memmove___3BII
275
 
JNIEXPORT void JNICALL C_NATIVE(memmove___3BII)
276
 
        (JNIEnv *env, jclass that, jbyteArray arg0, jint arg1, jint arg2)
 
362
#if (!defined(NO_memmove___3BII) && !defined(JNI64)) || (!defined(NO_memmove___3BJJ) && defined(JNI64))
 
363
#ifndef JNI64
 
364
JNIEXPORT void JNICALL C_NATIVE(memmove___3BII)(JNIEnv *env, jclass that, jbyteArray arg0, jintLong arg1, jintLong arg2)
 
365
#else
 
366
JNIEXPORT void JNICALL C_NATIVE(memmove___3BJJ)(JNIEnv *env, jclass that, jbyteArray arg0, jintLong arg1, jintLong arg2)
 
367
#endif
277
368
{
278
369
        jbyte *lparg0=NULL;
 
370
#ifndef JNI64
279
371
        C_NATIVE_ENTER(env, that, memmove___3BII_FUNC);
 
372
#else
 
373
        C_NATIVE_ENTER(env, that, memmove___3BJJ_FUNC);
 
374
#endif
280
375
#ifdef JNI_VERSION_1_2
281
376
        if (IS_JNI_1_2) {
282
377
                if (arg0) if ((lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL)) == NULL) goto fail;
295
390
        {
296
391
                if (arg0 && lparg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
297
392
        }
 
393
#ifndef JNI64
298
394
        C_NATIVE_EXIT(env, that, memmove___3BII_FUNC);
 
395
#else
 
396
        C_NATIVE_EXIT(env, that, memmove___3BJJ_FUNC);
 
397
#endif
299
398
}
300
399
#endif
301
400
 
302
 
#ifndef NO_memmove___3B_3CI
303
 
JNIEXPORT void JNICALL C_NATIVE(memmove___3B_3CI)
304
 
        (JNIEnv *env, jclass that, jbyteArray arg0, jcharArray arg1, jint arg2)
 
401
#if (!defined(NO_memmove___3B_3CI) && !defined(JNI64)) || (!defined(NO_memmove___3B_3CJ) && defined(JNI64))
 
402
#ifndef JNI64
 
403
JNIEXPORT void JNICALL C_NATIVE(memmove___3B_3CI)(JNIEnv *env, jclass that, jbyteArray arg0, jcharArray arg1, jintLong arg2)
 
404
#else
 
405
JNIEXPORT void JNICALL C_NATIVE(memmove___3B_3CJ)(JNIEnv *env, jclass that, jbyteArray arg0, jcharArray arg1, jintLong arg2)
 
406
#endif
305
407
{
306
408
        jbyte *lparg0=NULL;
307
409
        jchar *lparg1=NULL;
 
410
#ifndef JNI64
308
411
        C_NATIVE_ENTER(env, that, memmove___3B_3CI_FUNC);
 
412
#else
 
413
        C_NATIVE_ENTER(env, that, memmove___3B_3CJ_FUNC);
 
414
#endif
309
415
#ifdef JNI_VERSION_1_2
310
416
        if (IS_JNI_1_2) {
311
417
                if (arg0) if ((lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL)) == NULL) goto fail;
328
434
                if (arg1 && lparg1) (*env)->ReleaseCharArrayElements(env, arg1, lparg1, JNI_ABORT);
329
435
                if (arg0 && lparg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
330
436
        }
 
437
#ifndef JNI64
331
438
        C_NATIVE_EXIT(env, that, memmove___3B_3CI_FUNC);
 
439
#else
 
440
        C_NATIVE_EXIT(env, that, memmove___3B_3CJ_FUNC);
 
441
#endif
332
442
}
333
443
#endif
334
444
 
335
 
#ifndef NO_memmove___3CII
336
 
JNIEXPORT void JNICALL C_NATIVE(memmove___3CII)
337
 
        (JNIEnv *env, jclass that, jcharArray arg0, jint arg1, jint arg2)
 
445
#if (!defined(NO_memmove___3CII) && !defined(JNI64)) || (!defined(NO_memmove___3CJJ) && defined(JNI64))
 
446
#ifndef JNI64
 
447
JNIEXPORT void JNICALL C_NATIVE(memmove___3CII)(JNIEnv *env, jclass that, jcharArray arg0, jintLong arg1, jintLong arg2)
 
448
#else
 
449
JNIEXPORT void JNICALL C_NATIVE(memmove___3CJJ)(JNIEnv *env, jclass that, jcharArray arg0, jintLong arg1, jintLong arg2)
 
450
#endif
338
451
{
339
452
        jchar *lparg0=NULL;
 
453
#ifndef JNI64
340
454
        C_NATIVE_ENTER(env, that, memmove___3CII_FUNC);
 
455
#else
 
456
        C_NATIVE_ENTER(env, that, memmove___3CJJ_FUNC);
 
457
#endif
341
458
#ifdef JNI_VERSION_1_2
342
459
        if (IS_JNI_1_2) {
343
460
                if (arg0) if ((lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL)) == NULL) goto fail;
356
473
        {
357
474
                if (arg0 && lparg0) (*env)->ReleaseCharArrayElements(env, arg0, lparg0, 0);
358
475
        }
 
476
#ifndef JNI64
359
477
        C_NATIVE_EXIT(env, that, memmove___3CII_FUNC);
 
478
#else
 
479
        C_NATIVE_EXIT(env, that, memmove___3CJJ_FUNC);
 
480
#endif
360
481
}
361
482
#endif
362
483
 
363
 
#ifndef NO_memmove___3DII
364
 
JNIEXPORT void JNICALL C_NATIVE(memmove___3DII)
365
 
        (JNIEnv *env, jclass that, jdoubleArray arg0, jint arg1, jint arg2)
 
484
#if (!defined(NO_memmove___3DII) && !defined(JNI64)) || (!defined(NO_memmove___3DJJ) && defined(JNI64))
 
485
#ifndef JNI64
 
486
JNIEXPORT void JNICALL C_NATIVE(memmove___3DII)(JNIEnv *env, jclass that, jdoubleArray arg0, jintLong arg1, jintLong arg2)
 
487
#else
 
488
JNIEXPORT void JNICALL C_NATIVE(memmove___3DJJ)(JNIEnv *env, jclass that, jdoubleArray arg0, jintLong arg1, jintLong arg2)
 
489
#endif
366
490
{
367
491
        jdouble *lparg0=NULL;
 
492
#ifndef JNI64
368
493
        C_NATIVE_ENTER(env, that, memmove___3DII_FUNC);
 
494
#else
 
495
        C_NATIVE_ENTER(env, that, memmove___3DJJ_FUNC);
 
496
#endif
369
497
#ifdef JNI_VERSION_1_2
370
498
        if (IS_JNI_1_2) {
371
499
                if (arg0) if ((lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL)) == NULL) goto fail;
384
512
        {
385
513
                if (arg0 && lparg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
386
514
        }
 
515
#ifndef JNI64
387
516
        C_NATIVE_EXIT(env, that, memmove___3DII_FUNC);
 
517
#else
 
518
        C_NATIVE_EXIT(env, that, memmove___3DJJ_FUNC);
 
519
#endif
388
520
}
389
521
#endif
390
522
 
391
 
#ifndef NO_memmove___3FII
392
 
JNIEXPORT void JNICALL C_NATIVE(memmove___3FII)
393
 
        (JNIEnv *env, jclass that, jfloatArray arg0, jint arg1, jint arg2)
 
523
#if (!defined(NO_memmove___3FII) && !defined(JNI64)) || (!defined(NO_memmove___3FJJ) && defined(JNI64))
 
524
#ifndef JNI64
 
525
JNIEXPORT void JNICALL C_NATIVE(memmove___3FII)(JNIEnv *env, jclass that, jfloatArray arg0, jintLong arg1, jintLong arg2)
 
526
#else
 
527
JNIEXPORT void JNICALL C_NATIVE(memmove___3FJJ)(JNIEnv *env, jclass that, jfloatArray arg0, jintLong arg1, jintLong arg2)
 
528
#endif
394
529
{
395
530
        jfloat *lparg0=NULL;
 
531
#ifndef JNI64
396
532
        C_NATIVE_ENTER(env, that, memmove___3FII_FUNC);
 
533
#else
 
534
        C_NATIVE_ENTER(env, that, memmove___3FJJ_FUNC);
 
535
#endif
397
536
#ifdef JNI_VERSION_1_2
398
537
        if (IS_JNI_1_2) {
399
538
                if (arg0) if ((lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL)) == NULL) goto fail;
412
551
        {
413
552
                if (arg0 && lparg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
414
553
        }
 
554
#ifndef JNI64
415
555
        C_NATIVE_EXIT(env, that, memmove___3FII_FUNC);
 
556
#else
 
557
        C_NATIVE_EXIT(env, that, memmove___3FJJ_FUNC);
 
558
#endif
416
559
}
417
560
#endif
418
561
 
419
 
#ifndef NO_memmove___3III
420
 
JNIEXPORT void JNICALL C_NATIVE(memmove___3III)
421
 
        (JNIEnv *env, jclass that, jintArray arg0, jint arg1, jint arg2)
 
562
#if (!defined(NO_memmove___3III) && !defined(JNI64)) || (!defined(NO_memmove___3IJJ) && defined(JNI64))
 
563
#ifndef JNI64
 
564
JNIEXPORT void JNICALL C_NATIVE(memmove___3III)(JNIEnv *env, jclass that, jintArray arg0, jintLong arg1, jintLong arg2)
 
565
#else
 
566
JNIEXPORT void JNICALL C_NATIVE(memmove___3IJJ)(JNIEnv *env, jclass that, jintArray arg0, jintLong arg1, jintLong arg2)
 
567
#endif
422
568
{
423
569
        jint *lparg0=NULL;
 
570
#ifndef JNI64
424
571
        C_NATIVE_ENTER(env, that, memmove___3III_FUNC);
 
572
#else
 
573
        C_NATIVE_ENTER(env, that, memmove___3IJJ_FUNC);
 
574
#endif
425
575
#ifdef JNI_VERSION_1_2
426
576
        if (IS_JNI_1_2) {
427
577
                if (arg0) if ((lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL)) == NULL) goto fail;
440
590
        {
441
591
                if (arg0 && lparg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
442
592
        }
 
593
#ifndef JNI64
443
594
        C_NATIVE_EXIT(env, that, memmove___3III_FUNC);
 
595
#else
 
596
        C_NATIVE_EXIT(env, that, memmove___3IJJ_FUNC);
 
597
#endif
444
598
}
445
599
#endif
446
600
 
447
 
#ifndef NO_memmove___3I_3BI
448
 
JNIEXPORT void JNICALL C_NATIVE(memmove___3I_3BI)
449
 
        (JNIEnv *env, jclass that, jintArray arg0, jbyteArray arg1, jint arg2)
 
601
#if (!defined(NO_memmove___3I_3BI) && !defined(JNI64)) || (!defined(NO_memmove___3I_3BJ) && defined(JNI64))
 
602
#ifndef JNI64
 
603
JNIEXPORT void JNICALL C_NATIVE(memmove___3I_3BI)(JNIEnv *env, jclass that, jintArray arg0, jbyteArray arg1, jintLong arg2)
 
604
#else
 
605
JNIEXPORT void JNICALL C_NATIVE(memmove___3I_3BJ)(JNIEnv *env, jclass that, jintArray arg0, jbyteArray arg1, jintLong arg2)
 
606
#endif
450
607
{
451
608
        jint *lparg0=NULL;
452
609
        jbyte *lparg1=NULL;
 
610
#ifndef JNI64
453
611
        C_NATIVE_ENTER(env, that, memmove___3I_3BI_FUNC);
 
612
#else
 
613
        C_NATIVE_ENTER(env, that, memmove___3I_3BJ_FUNC);
 
614
#endif
454
615
        if (arg1) if ((lparg1 = (*env)->GetByteArrayElements(env, arg1, NULL)) == NULL) goto fail;
455
616
#ifdef JNI_VERSION_1_2
456
617
        if (IS_JNI_1_2) {
471
632
                if (arg0 && lparg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
472
633
        }
473
634
        if (arg1 && lparg1) (*env)->ReleaseByteArrayElements(env, arg1, lparg1, 0);
 
635
#ifndef JNI64
474
636
        C_NATIVE_EXIT(env, that, memmove___3I_3BI_FUNC);
 
637
#else
 
638
        C_NATIVE_EXIT(env, that, memmove___3I_3BJ_FUNC);
 
639
#endif
475
640
}
476
641
#endif
477
642
 
478
 
#ifndef NO_memmove___3JII
479
 
JNIEXPORT void JNICALL C_NATIVE(memmove___3JII)
480
 
        (JNIEnv *env, jclass that, jlongArray arg0, jint arg1, jint arg2)
 
643
#if (!defined(NO_memmove___3JII) && !defined(JNI64)) || (!defined(NO_memmove___3JJJ) && defined(JNI64))
 
644
#ifndef JNI64
 
645
JNIEXPORT void JNICALL C_NATIVE(memmove___3JII)(JNIEnv *env, jclass that, jlongArray arg0, jintLong arg1, jintLong arg2)
 
646
#else
 
647
JNIEXPORT void JNICALL C_NATIVE(memmove___3JJJ)(JNIEnv *env, jclass that, jlongArray arg0, jintLong arg1, jintLong arg2)
 
648
#endif
481
649
{
482
650
        jlong *lparg0=NULL;
 
651
#ifndef JNI64
483
652
        C_NATIVE_ENTER(env, that, memmove___3JII_FUNC);
 
653
#else
 
654
        C_NATIVE_ENTER(env, that, memmove___3JJJ_FUNC);
 
655
#endif
484
656
#ifdef JNI_VERSION_1_2
485
657
        if (IS_JNI_1_2) {
486
658
                if (arg0) if ((lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL)) == NULL) goto fail;
499
671
        {
500
672
                if (arg0 && lparg0) (*env)->ReleaseLongArrayElements(env, arg0, lparg0, 0);
501
673
        }
 
674
#ifndef JNI64
502
675
        C_NATIVE_EXIT(env, that, memmove___3JII_FUNC);
 
676
#else
 
677
        C_NATIVE_EXIT(env, that, memmove___3JJJ_FUNC);
 
678
#endif
503
679
}
504
680
#endif
505
681
 
506
 
#ifndef NO_memmove___3SII
507
 
JNIEXPORT void JNICALL C_NATIVE(memmove___3SII)
508
 
        (JNIEnv *env, jclass that, jshortArray arg0, jint arg1, jint arg2)
 
682
#if (!defined(NO_memmove___3SII) && !defined(JNI64)) || (!defined(NO_memmove___3SJJ) && defined(JNI64))
 
683
#ifndef JNI64
 
684
JNIEXPORT void JNICALL C_NATIVE(memmove___3SII)(JNIEnv *env, jclass that, jshortArray arg0, jintLong arg1, jintLong arg2)
 
685
#else
 
686
JNIEXPORT void JNICALL C_NATIVE(memmove___3SJJ)(JNIEnv *env, jclass that, jshortArray arg0, jintLong arg1, jintLong arg2)
 
687
#endif
509
688
{
510
689
        jshort *lparg0=NULL;
 
690
#ifndef JNI64
511
691
        C_NATIVE_ENTER(env, that, memmove___3SII_FUNC);
 
692
#else
 
693
        C_NATIVE_ENTER(env, that, memmove___3SJJ_FUNC);
 
694
#endif
512
695
#ifdef JNI_VERSION_1_2
513
696
        if (IS_JNI_1_2) {
514
697
                if (arg0) if ((lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL)) == NULL) goto fail;
527
710
        {
528
711
                if (arg0 && lparg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
529
712
        }
 
713
#ifndef JNI64
530
714
        C_NATIVE_EXIT(env, that, memmove___3SII_FUNC);
 
715
#else
 
716
        C_NATIVE_EXIT(env, that, memmove___3SJJ_FUNC);
 
717
#endif
531
718
}
532
719
#endif
533
720
 
534
721
#ifndef NO_memset
535
 
JNIEXPORT jint JNICALL C_NATIVE(memset)
536
 
        (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
 
722
JNIEXPORT jintLong JNICALL C_NATIVE(memset)
 
723
        (JNIEnv *env, jclass that, jintLong arg0, jint arg1, jintLong arg2)
537
724
{
538
 
        jint rc = 0;
 
725
        jintLong rc = 0;
539
726
        C_NATIVE_ENTER(env, that, memset_FUNC);
540
 
        rc = (jint)memset((void *)arg0, arg1, (size_t)arg2);
 
727
        rc = (jintLong)memset((void *)arg0, arg1, (size_t)arg2);
541
728
        C_NATIVE_EXIT(env, that, memset_FUNC);
542
729
        return rc;
543
730
}
545
732
 
546
733
#ifndef NO_strlen
547
734
JNIEXPORT jint JNICALL C_NATIVE(strlen)
548
 
        (JNIEnv *env, jclass that, jint arg0)
 
735
        (JNIEnv *env, jclass that, jintLong arg0)
549
736
{
550
737
        jint rc = 0;
551
738
        C_NATIVE_ENTER(env, that, strlen_FUNC);