← Back to branch summary

~netrek-developers/netrek-client-cow/trunk

« back to all changes in this revision

Viewing changes to java/_stubs/java_lang_String.c

  • Committer: Collin Pruitt
  • Date: 2009-05-12 04:30:09 UTC
  • Revision ID: collinp111@gmail.com-20090512043009-3jsjojoyrk16oass
Initial upload - updated from http://james.tooraweenah.com/darcs/netrek-client-cow/ using darcs (hince the existnace of _darcs), fully patched.

Show diffs side-by-side

added added

removed removed

Lines of Context:
java/_stubs/java_lang_String.c
 
1
/* DO NOT EDIT THIS FILE - it is machine generated */
 
2
#include "jri.h"
 
3
 
 
4
/* Stubs for class java/lang/String */
 
5
 
 
6
#ifdef IMPLEMENT_java_lang_String
 
7
#define _implementing_java_lang_String
 
8
#endif /* IMPLEMENT_java_lang_String */
 
9
#define IMPLEMENT_java_lang_String
 
10
#include "java_lang_String.h"
 
11
 
 
12
#ifndef UNUSED_java_lang_String_value
 
13
JRIFieldID FAR fieldID_java_lang_String_value = JRIUninitialized;
 
14
#ifdef DEBUG
 
15
JRI_PUBLIC_API(jref)
 
16
get_java_lang_String_value(JRIEnv* env, struct java_lang_String* obj) {
 
17
        if (fieldID_java_lang_String_value == JRIUninitialized) {
 
18
                assert(!"Forgot to call use_java_lang_String(env) before accessing field value [C");
 
19
        }
 
20
        return (jref)
 
21
                JRI_GetField(env, obj, fieldID_java_lang_String_value);
 
22
}
 
23
JRI_PUBLIC_API(void)
 
24
set_java_lang_String_value(JRIEnv* env, struct java_lang_String* obj, jref v) {
 
25
        if (fieldID_java_lang_String_value == JRIUninitialized) {
 
26
                assert(!"Forgot to call use_java_lang_String(env) before accessing field value [C");
 
27
        }
 
28
        JRI_SetField(env, obj, fieldID_java_lang_String_value, v);
 
29
}
 
30
#endif /* DEBUG */
 
31
#endif /* UNUSED_java_lang_String_value */
 
32
 
 
33
#ifndef UNUSED_java_lang_String_offset
 
34
JRIFieldID FAR fieldID_java_lang_String_offset = JRIUninitialized;
 
35
#ifdef DEBUG
 
36
JRI_PUBLIC_API(jint)
 
37
get_java_lang_String_offset(JRIEnv* env, struct java_lang_String* obj) {
 
38
        if (fieldID_java_lang_String_offset == JRIUninitialized) {
 
39
                assert(!"Forgot to call use_java_lang_String(env) before accessing field offset I");
 
40
        }
 
41
        return JRI_GetFieldInt(env, obj, fieldID_java_lang_String_offset);
 
42
}
 
43
JRI_PUBLIC_API(void)
 
44
set_java_lang_String_offset(JRIEnv* env, struct java_lang_String* obj, jint v) {
 
45
        if (fieldID_java_lang_String_offset == JRIUninitialized) {
 
46
                assert(!"Forgot to call use_java_lang_String(env) before accessing field offset I");
 
47
        }
 
48
        JRI_SetFieldInt(env, obj, fieldID_java_lang_String_offset, v);
 
49
}
 
50
#endif /* DEBUG */
 
51
#endif /* UNUSED_java_lang_String_offset */
 
52
 
 
53
#ifndef UNUSED_java_lang_String_count
 
54
JRIFieldID FAR fieldID_java_lang_String_count = JRIUninitialized;
 
55
#ifdef DEBUG
 
56
JRI_PUBLIC_API(jint)
 
57
get_java_lang_String_count(JRIEnv* env, struct java_lang_String* obj) {
 
58
        if (fieldID_java_lang_String_count == JRIUninitialized) {
 
59
                assert(!"Forgot to call use_java_lang_String(env) before accessing field count I");
 
60
        }
 
61
        return JRI_GetFieldInt(env, obj, fieldID_java_lang_String_count);
 
62
}
 
63
JRI_PUBLIC_API(void)
 
64
set_java_lang_String_count(JRIEnv* env, struct java_lang_String* obj, jint v) {
 
65
        if (fieldID_java_lang_String_count == JRIUninitialized) {
 
66
                assert(!"Forgot to call use_java_lang_String(env) before accessing field count I");
 
67
        }
 
68
        JRI_SetFieldInt(env, obj, fieldID_java_lang_String_count, v);
 
69
}
 
70
#endif /* DEBUG */
 
71
#endif /* UNUSED_java_lang_String_count */
 
72
 
 
73
#ifndef UNUSED_java_lang_String_InternSet
 
74
JRIFieldID FAR fieldID_java_lang_String_InternSet = JRIUninitialized;
 
75
#ifdef DEBUG
 
76
struct java_util_Hashtable;
 
77
JRI_PUBLIC_API(struct java_util_Hashtable *)
 
78
get_java_lang_String_InternSet(JRIEnv* env, struct java_lang_Class* clazz) {
 
79
        if (fieldID_java_lang_String_InternSet == JRIUninitialized) {
 
80
                assert(!"Forgot to call use_java_lang_String(env) before accessing field InternSet Ljava/util/Hashtable;");
 
81
        }
 
82
        return (struct java_util_Hashtable *)
 
83
                JRI_GetStaticField(env, clazz, fieldID_java_lang_String_InternSet);
 
84
}
 
85
JRI_PUBLIC_API(void)
 
86
set_java_lang_String_InternSet(JRIEnv* env, struct java_lang_Class* clazz, struct java_util_Hashtable * v) {
 
87
        if (fieldID_java_lang_String_InternSet == JRIUninitialized) {
 
88
                assert(!"Forgot to call use_java_lang_String(env) before accessing field InternSet Ljava/util/Hashtable;");
 
89
        }
 
90
        JRI_SetStaticField(env, clazz, fieldID_java_lang_String_InternSet, v);
 
91
}
 
92
#endif /* DEBUG */
 
93
#endif /* UNUSED_java_lang_String_InternSet */
 
94
 
 
95
#ifndef UNUSED_java_lang_String_new
 
96
JRIMethodID FAR methodID_java_lang_String_new = JRIUninitialized;
 
97
#ifdef DEBUG
 
98
JRI_PUBLIC_API(struct java_lang_String*)
 
99
java_lang_String_new(JRIEnv* env, struct java_lang_Class* clazz) {
 
100
        if (methodID_java_lang_String_new == JRIUninitialized) {
 
101
                assert(!"Forgot to call use_java_lang_String(env) before calling method <init> ()V");
 
102
        }
 
103
        return (struct java_lang_String*)JRI_NewObject(env)(env, JRI_NewObject_op, clazz, methodID_java_lang_String_new);
 
104
}
 
105
#endif /* DEBUG */
 
106
#endif /* UNUSED_java_lang_String_new */
 
107
 
 
108
#ifndef UNUSED_java_lang_String_new_1
 
109
JRIMethodID FAR methodID_java_lang_String_new_1 = JRIUninitialized;
 
110
#ifdef DEBUG
 
111
JRI_PUBLIC_API(struct java_lang_String*)
 
112
java_lang_String_new_1(JRIEnv* env, struct java_lang_Class* clazz, struct java_lang_String *a) {
 
113
        if (methodID_java_lang_String_new_1 == JRIUninitialized) {
 
114
                assert(!"Forgot to call use_java_lang_String(env) before calling method <init> (Ljava/lang/String;)V");
 
115
        }
 
116
        return (struct java_lang_String*)JRI_NewObject(env)(env, JRI_NewObject_op, clazz, methodID_java_lang_String_new_1, a);
 
117
}
 
118
#endif /* DEBUG */
 
119
#endif /* UNUSED_java_lang_String_new_1 */
 
120
 
 
121
#ifndef UNUSED_java_lang_String_new_2
 
122
JRIMethodID FAR methodID_java_lang_String_new_2 = JRIUninitialized;
 
123
#ifdef DEBUG
 
124
JRI_PUBLIC_API(struct java_lang_String*)
 
125
java_lang_String_new_2(JRIEnv* env, struct java_lang_Class* clazz, jcharArray a) {
 
126
        if (methodID_java_lang_String_new_2 == JRIUninitialized) {
 
127
                assert(!"Forgot to call use_java_lang_String(env) before calling method <init> ([C)V");
 
128
        }
 
129
        return (struct java_lang_String*)JRI_NewObject(env)(env, JRI_NewObject_op, clazz, methodID_java_lang_String_new_2, a);
 
130
}
 
131
#endif /* DEBUG */
 
132
#endif /* UNUSED_java_lang_String_new_2 */
 
133
 
 
134
#ifndef UNUSED_java_lang_String_new_3
 
135
JRIMethodID FAR methodID_java_lang_String_new_3 = JRIUninitialized;
 
136
#ifdef DEBUG
 
137
JRI_PUBLIC_API(struct java_lang_String*)
 
138
java_lang_String_new_3(JRIEnv* env, struct java_lang_Class* clazz, jcharArray a, jint b, jint c) {
 
139
        if (methodID_java_lang_String_new_3 == JRIUninitialized) {
 
140
                assert(!"Forgot to call use_java_lang_String(env) before calling method <init> ([CII)V");
 
141
        }
 
142
        return (struct java_lang_String*)JRI_NewObject(env)(env, JRI_NewObject_op, clazz, methodID_java_lang_String_new_3, a, b, c);
 
143
}
 
144
#endif /* DEBUG */
 
145
#endif /* UNUSED_java_lang_String_new_3 */
 
146
 
 
147
#ifndef UNUSED_java_lang_String_new_4
 
148
JRIMethodID FAR methodID_java_lang_String_new_4 = JRIUninitialized;
 
149
#ifdef DEBUG
 
150
JRI_PUBLIC_API(struct java_lang_String*)
 
151
java_lang_String_new_4(JRIEnv* env, struct java_lang_Class* clazz, jbyteArray a, jint b, jint c, jint d) {
 
152
        if (methodID_java_lang_String_new_4 == JRIUninitialized) {
 
153
                assert(!"Forgot to call use_java_lang_String(env) before calling method <init> ([BIII)V");
 
154
        }
 
155
        return (struct java_lang_String*)JRI_NewObject(env)(env, JRI_NewObject_op, clazz, methodID_java_lang_String_new_4, a, b, c, d);
 
156
}
 
157
#endif /* DEBUG */
 
158
#endif /* UNUSED_java_lang_String_new_4 */
 
159
 
 
160
#ifndef UNUSED_java_lang_String_new_5
 
161
JRIMethodID FAR methodID_java_lang_String_new_5 = JRIUninitialized;
 
162
#ifdef DEBUG
 
163
JRI_PUBLIC_API(struct java_lang_String*)
 
164
java_lang_String_new_5(JRIEnv* env, struct java_lang_Class* clazz, jbyteArray a, jint b) {
 
165
        if (methodID_java_lang_String_new_5 == JRIUninitialized) {
 
166
                assert(!"Forgot to call use_java_lang_String(env) before calling method <init> ([BI)V");
 
167
        }
 
168
        return (struct java_lang_String*)JRI_NewObject(env)(env, JRI_NewObject_op, clazz, methodID_java_lang_String_new_5, a, b);
 
169
}
 
170
#endif /* DEBUG */
 
171
#endif /* UNUSED_java_lang_String_new_5 */
 
172
 
 
173
#ifndef UNUSED_java_lang_String_new_6
 
174
JRIMethodID FAR methodID_java_lang_String_new_6 = JRIUninitialized;
 
175
#ifdef DEBUG
 
176
JRI_PUBLIC_API(struct java_lang_String*)
 
177
java_lang_String_new_6(JRIEnv* env, struct java_lang_Class* clazz, struct java_lang_StringBuffer *a) {
 
178
        if (methodID_java_lang_String_new_6 == JRIUninitialized) {
 
179
                assert(!"Forgot to call use_java_lang_String(env) before calling method <init> (Ljava/lang/StringBuffer;)V");
 
180
        }
 
181
        return (struct java_lang_String*)JRI_NewObject(env)(env, JRI_NewObject_op, clazz, methodID_java_lang_String_new_6, a);
 
182
}
 
183
#endif /* DEBUG */
 
184
#endif /* UNUSED_java_lang_String_new_6 */
 
185
 
 
186
#ifndef UNUSED_java_lang_String_new_7
 
187
JRIMethodID FAR methodID_java_lang_String_new_7 = JRIUninitialized;
 
188
#ifdef DEBUG
 
189
JRI_PUBLIC_API(struct java_lang_String*)
 
190
java_lang_String_new_7(JRIEnv* env, struct java_lang_Class* clazz, jint a, jint b, jcharArray c) {
 
191
        if (methodID_java_lang_String_new_7 == JRIUninitialized) {
 
192
                assert(!"Forgot to call use_java_lang_String(env) before calling method <init> (II[C)V");
 
193
        }
 
194
        return (struct java_lang_String*)JRI_NewObject(env)(env, JRI_NewObject_op, clazz, methodID_java_lang_String_new_7, a, b, c);
 
195
}
 
196
#endif /* DEBUG */
 
197
#endif /* UNUSED_java_lang_String_new_7 */
 
198
 
 
199
#ifndef UNUSED_java_lang_String_length
 
200
JRIMethodID FAR methodID_java_lang_String_length = JRIUninitialized;
 
201
#ifdef DEBUG
 
202
JRI_PUBLIC_API(jint)
 
203
java_lang_String_length(JRIEnv* env, struct java_lang_String* self) {
 
204
        if (methodID_java_lang_String_length == JRIUninitialized) {
 
205
                assert(!"Forgot to call use_java_lang_String(env) before calling method length ()I");
 
206
        }
 
207
        return (jint)JRI_CallMethodInt(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_length);
 
208
}
 
209
#endif /* DEBUG */
 
210
#endif /* UNUSED_java_lang_String_length */
 
211
 
 
212
#ifndef UNUSED_java_lang_String_charAt
 
213
JRIMethodID FAR methodID_java_lang_String_charAt = JRIUninitialized;
 
214
#ifdef DEBUG
 
215
JRI_PUBLIC_API(jchar)
 
216
java_lang_String_charAt(JRIEnv* env, struct java_lang_String* self, jint a) {
 
217
        if (methodID_java_lang_String_charAt == JRIUninitialized) {
 
218
                assert(!"Forgot to call use_java_lang_String(env) before calling method charAt (I)C");
 
219
        }
 
220
        return (jchar)JRI_CallMethodChar(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_charAt, a);
 
221
}
 
222
#endif /* DEBUG */
 
223
#endif /* UNUSED_java_lang_String_charAt */
 
224
 
 
225
#ifndef UNUSED_java_lang_String_getChars
 
226
JRIMethodID FAR methodID_java_lang_String_getChars = JRIUninitialized;
 
227
#ifdef DEBUG
 
228
JRI_PUBLIC_API(void)
 
229
java_lang_String_getChars(JRIEnv* env, struct java_lang_String* self, jint a, jint b, jcharArray c, jint d) {
 
230
        if (methodID_java_lang_String_getChars == JRIUninitialized) {
 
231
                assert(!"Forgot to call use_java_lang_String(env) before calling method getChars (II[CI)V");
 
232
        }
 
233
        (void)JRI_CallMethod(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_getChars, a, b, c, d);
 
234
}
 
235
#endif /* DEBUG */
 
236
#endif /* UNUSED_java_lang_String_getChars */
 
237
 
 
238
#ifndef UNUSED_java_lang_String_getBytes
 
239
JRIMethodID FAR methodID_java_lang_String_getBytes = JRIUninitialized;
 
240
#ifdef DEBUG
 
241
JRI_PUBLIC_API(void)
 
242
java_lang_String_getBytes(JRIEnv* env, struct java_lang_String* self, jint a, jint b, jbyteArray c, jint d) {
 
243
        if (methodID_java_lang_String_getBytes == JRIUninitialized) {
 
244
                assert(!"Forgot to call use_java_lang_String(env) before calling method getBytes (II[BI)V");
 
245
        }
 
246
        (void)JRI_CallMethod(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_getBytes, a, b, c, d);
 
247
}
 
248
#endif /* DEBUG */
 
249
#endif /* UNUSED_java_lang_String_getBytes */
 
250
 
 
251
#ifndef UNUSED_java_lang_String_equals
 
252
JRIMethodID FAR methodID_java_lang_String_equals = JRIUninitialized;
 
253
#ifdef DEBUG
 
254
JRI_PUBLIC_API(jbool)
 
255
java_lang_String_equals(JRIEnv* env, struct java_lang_String* self, struct java_lang_Object *a) {
 
256
        if (methodID_java_lang_String_equals == JRIUninitialized) {
 
257
                assert(!"Forgot to call use_java_lang_String(env) before calling method equals (Ljava/lang/Object;)Z");
 
258
        }
 
259
        return (jbool)JRI_CallMethodBoolean(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_equals, a);
 
260
}
 
261
#endif /* DEBUG */
 
262
#endif /* UNUSED_java_lang_String_equals */
 
263
 
 
264
#ifndef UNUSED_java_lang_String_equalsIgnoreCase
 
265
JRIMethodID FAR methodID_java_lang_String_equalsIgnoreCase = JRIUninitialized;
 
266
#ifdef DEBUG
 
267
JRI_PUBLIC_API(jbool)
 
268
java_lang_String_equalsIgnoreCase(JRIEnv* env, struct java_lang_String* self, struct java_lang_String *a) {
 
269
        if (methodID_java_lang_String_equalsIgnoreCase == JRIUninitialized) {
 
270
                assert(!"Forgot to call use_java_lang_String(env) before calling method equalsIgnoreCase (Ljava/lang/String;)Z");
 
271
        }
 
272
        return (jbool)JRI_CallMethodBoolean(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_equalsIgnoreCase, a);
 
273
}
 
274
#endif /* DEBUG */
 
275
#endif /* UNUSED_java_lang_String_equalsIgnoreCase */
 
276
 
 
277
#ifndef UNUSED_java_lang_String_compareTo
 
278
JRIMethodID FAR methodID_java_lang_String_compareTo = JRIUninitialized;
 
279
#ifdef DEBUG
 
280
JRI_PUBLIC_API(jint)
 
281
java_lang_String_compareTo(JRIEnv* env, struct java_lang_String* self, struct java_lang_String *a) {
 
282
        if (methodID_java_lang_String_compareTo == JRIUninitialized) {
 
283
                assert(!"Forgot to call use_java_lang_String(env) before calling method compareTo (Ljava/lang/String;)I");
 
284
        }
 
285
        return (jint)JRI_CallMethodInt(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_compareTo, a);
 
286
}
 
287
#endif /* DEBUG */
 
288
#endif /* UNUSED_java_lang_String_compareTo */
 
289
 
 
290
#ifndef UNUSED_java_lang_String_regionMatches
 
291
JRIMethodID FAR methodID_java_lang_String_regionMatches = JRIUninitialized;
 
292
#ifdef DEBUG
 
293
JRI_PUBLIC_API(jbool)
 
294
java_lang_String_regionMatches(JRIEnv* env, struct java_lang_String* self, jint a, struct java_lang_String *b, jint c, jint d) {
 
295
        if (methodID_java_lang_String_regionMatches == JRIUninitialized) {
 
296
                assert(!"Forgot to call use_java_lang_String(env) before calling method regionMatches (ILjava/lang/String;II)Z");
 
297
        }
 
298
        return (jbool)JRI_CallMethodBoolean(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_regionMatches, a, b, c, d);
 
299
}
 
300
#endif /* DEBUG */
 
301
#endif /* UNUSED_java_lang_String_regionMatches */
 
302
 
 
303
#ifndef UNUSED_java_lang_String_regionMatches_1
 
304
JRIMethodID FAR methodID_java_lang_String_regionMatches_1 = JRIUninitialized;
 
305
#ifdef DEBUG
 
306
JRI_PUBLIC_API(jbool)
 
307
java_lang_String_regionMatches_1(JRIEnv* env, struct java_lang_String* self, jbool a, jint b, struct java_lang_String *c, jint d, jint e) {
 
308
        if (methodID_java_lang_String_regionMatches_1 == JRIUninitialized) {
 
309
                assert(!"Forgot to call use_java_lang_String(env) before calling method regionMatches (ZILjava/lang/String;II)Z");
 
310
        }
 
311
        return (jbool)JRI_CallMethodBoolean(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_regionMatches_1, a, b, c, d, e);
 
312
}
 
313
#endif /* DEBUG */
 
314
#endif /* UNUSED_java_lang_String_regionMatches_1 */
 
315
 
 
316
#ifndef UNUSED_java_lang_String_startsWith
 
317
JRIMethodID FAR methodID_java_lang_String_startsWith = JRIUninitialized;
 
318
#ifdef DEBUG
 
319
JRI_PUBLIC_API(jbool)
 
320
java_lang_String_startsWith(JRIEnv* env, struct java_lang_String* self, struct java_lang_String *a, jint b) {
 
321
        if (methodID_java_lang_String_startsWith == JRIUninitialized) {
 
322
                assert(!"Forgot to call use_java_lang_String(env) before calling method startsWith (Ljava/lang/String;I)Z");
 
323
        }
 
324
        return (jbool)JRI_CallMethodBoolean(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_startsWith, a, b);
 
325
}
 
326
#endif /* DEBUG */
 
327
#endif /* UNUSED_java_lang_String_startsWith */
 
328
 
 
329
#ifndef UNUSED_java_lang_String_startsWith_1
 
330
JRIMethodID FAR methodID_java_lang_String_startsWith_1 = JRIUninitialized;
 
331
#ifdef DEBUG
 
332
JRI_PUBLIC_API(jbool)
 
333
java_lang_String_startsWith_1(JRIEnv* env, struct java_lang_String* self, struct java_lang_String *a) {
 
334
        if (methodID_java_lang_String_startsWith_1 == JRIUninitialized) {
 
335
                assert(!"Forgot to call use_java_lang_String(env) before calling method startsWith (Ljava/lang/String;)Z");
 
336
        }
 
337
        return (jbool)JRI_CallMethodBoolean(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_startsWith_1, a);
 
338
}
 
339
#endif /* DEBUG */
 
340
#endif /* UNUSED_java_lang_String_startsWith_1 */
 
341
 
 
342
#ifndef UNUSED_java_lang_String_endsWith
 
343
JRIMethodID FAR methodID_java_lang_String_endsWith = JRIUninitialized;
 
344
#ifdef DEBUG
 
345
JRI_PUBLIC_API(jbool)
 
346
java_lang_String_endsWith(JRIEnv* env, struct java_lang_String* self, struct java_lang_String *a) {
 
347
        if (methodID_java_lang_String_endsWith == JRIUninitialized) {
 
348
                assert(!"Forgot to call use_java_lang_String(env) before calling method endsWith (Ljava/lang/String;)Z");
 
349
        }
 
350
        return (jbool)JRI_CallMethodBoolean(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_endsWith, a);
 
351
}
 
352
#endif /* DEBUG */
 
353
#endif /* UNUSED_java_lang_String_endsWith */
 
354
 
 
355
#ifndef UNUSED_java_lang_String_hashCode
 
356
JRIMethodID FAR methodID_java_lang_String_hashCode = JRIUninitialized;
 
357
#ifdef DEBUG
 
358
JRI_PUBLIC_API(jint)
 
359
java_lang_String_hashCode(JRIEnv* env, struct java_lang_String* self) {
 
360
        if (methodID_java_lang_String_hashCode == JRIUninitialized) {
 
361
                assert(!"Forgot to call use_java_lang_String(env) before calling method hashCode ()I");
 
362
        }
 
363
        return (jint)JRI_CallMethodInt(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_hashCode);
 
364
}
 
365
#endif /* DEBUG */
 
366
#endif /* UNUSED_java_lang_String_hashCode */
 
367
 
 
368
#ifndef UNUSED_java_lang_String_indexOf
 
369
JRIMethodID FAR methodID_java_lang_String_indexOf = JRIUninitialized;
 
370
#ifdef DEBUG
 
371
JRI_PUBLIC_API(jint)
 
372
java_lang_String_indexOf(JRIEnv* env, struct java_lang_String* self, jint a) {
 
373
        if (methodID_java_lang_String_indexOf == JRIUninitialized) {
 
374
                assert(!"Forgot to call use_java_lang_String(env) before calling method indexOf (I)I");
 
375
        }
 
376
        return (jint)JRI_CallMethodInt(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_indexOf, a);
 
377
}
 
378
#endif /* DEBUG */
 
379
#endif /* UNUSED_java_lang_String_indexOf */
 
380
 
 
381
#ifndef UNUSED_java_lang_String_indexOf_1
 
382
JRIMethodID FAR methodID_java_lang_String_indexOf_1 = JRIUninitialized;
 
383
#ifdef DEBUG
 
384
JRI_PUBLIC_API(jint)
 
385
java_lang_String_indexOf_1(JRIEnv* env, struct java_lang_String* self, jint a, jint b) {
 
386
        if (methodID_java_lang_String_indexOf_1 == JRIUninitialized) {
 
387
                assert(!"Forgot to call use_java_lang_String(env) before calling method indexOf (II)I");
 
388
        }
 
389
        return (jint)JRI_CallMethodInt(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_indexOf_1, a, b);
 
390
}
 
391
#endif /* DEBUG */
 
392
#endif /* UNUSED_java_lang_String_indexOf_1 */
 
393
 
 
394
#ifndef UNUSED_java_lang_String_lastIndexOf
 
395
JRIMethodID FAR methodID_java_lang_String_lastIndexOf = JRIUninitialized;
 
396
#ifdef DEBUG
 
397
JRI_PUBLIC_API(jint)
 
398
java_lang_String_lastIndexOf(JRIEnv* env, struct java_lang_String* self, jint a) {
 
399
        if (methodID_java_lang_String_lastIndexOf == JRIUninitialized) {
 
400
                assert(!"Forgot to call use_java_lang_String(env) before calling method lastIndexOf (I)I");
 
401
        }
 
402
        return (jint)JRI_CallMethodInt(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_lastIndexOf, a);
 
403
}
 
404
#endif /* DEBUG */
 
405
#endif /* UNUSED_java_lang_String_lastIndexOf */
 
406
 
 
407
#ifndef UNUSED_java_lang_String_lastIndexOf_1
 
408
JRIMethodID FAR methodID_java_lang_String_lastIndexOf_1 = JRIUninitialized;
 
409
#ifdef DEBUG
 
410
JRI_PUBLIC_API(jint)
 
411
java_lang_String_lastIndexOf_1(JRIEnv* env, struct java_lang_String* self, jint a, jint b) {
 
412
        if (methodID_java_lang_String_lastIndexOf_1 == JRIUninitialized) {
 
413
                assert(!"Forgot to call use_java_lang_String(env) before calling method lastIndexOf (II)I");
 
414
        }
 
415
        return (jint)JRI_CallMethodInt(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_lastIndexOf_1, a, b);
 
416
}
 
417
#endif /* DEBUG */
 
418
#endif /* UNUSED_java_lang_String_lastIndexOf_1 */
 
419
 
 
420
#ifndef UNUSED_java_lang_String_indexOf_2
 
421
JRIMethodID FAR methodID_java_lang_String_indexOf_2 = JRIUninitialized;
 
422
#ifdef DEBUG
 
423
JRI_PUBLIC_API(jint)
 
424
java_lang_String_indexOf_2(JRIEnv* env, struct java_lang_String* self, struct java_lang_String *a) {
 
425
        if (methodID_java_lang_String_indexOf_2 == JRIUninitialized) {
 
426
                assert(!"Forgot to call use_java_lang_String(env) before calling method indexOf (Ljava/lang/String;)I");
 
427
        }
 
428
        return (jint)JRI_CallMethodInt(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_indexOf_2, a);
 
429
}
 
430
#endif /* DEBUG */
 
431
#endif /* UNUSED_java_lang_String_indexOf_2 */
 
432
 
 
433
#ifndef UNUSED_java_lang_String_indexOf_3
 
434
JRIMethodID FAR methodID_java_lang_String_indexOf_3 = JRIUninitialized;
 
435
#ifdef DEBUG
 
436
JRI_PUBLIC_API(jint)
 
437
java_lang_String_indexOf_3(JRIEnv* env, struct java_lang_String* self, struct java_lang_String *a, jint b) {
 
438
        if (methodID_java_lang_String_indexOf_3 == JRIUninitialized) {
 
439
                assert(!"Forgot to call use_java_lang_String(env) before calling method indexOf (Ljava/lang/String;I)I");
 
440
        }
 
441
        return (jint)JRI_CallMethodInt(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_indexOf_3, a, b);
 
442
}
 
443
#endif /* DEBUG */
 
444
#endif /* UNUSED_java_lang_String_indexOf_3 */
 
445
 
 
446
#ifndef UNUSED_java_lang_String_lastIndexOf_2
 
447
JRIMethodID FAR methodID_java_lang_String_lastIndexOf_2 = JRIUninitialized;
 
448
#ifdef DEBUG
 
449
JRI_PUBLIC_API(jint)
 
450
java_lang_String_lastIndexOf_2(JRIEnv* env, struct java_lang_String* self, struct java_lang_String *a) {
 
451
        if (methodID_java_lang_String_lastIndexOf_2 == JRIUninitialized) {
 
452
                assert(!"Forgot to call use_java_lang_String(env) before calling method lastIndexOf (Ljava/lang/String;)I");
 
453
        }
 
454
        return (jint)JRI_CallMethodInt(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_lastIndexOf_2, a);
 
455
}
 
456
#endif /* DEBUG */
 
457
#endif /* UNUSED_java_lang_String_lastIndexOf_2 */
 
458
 
 
459
#ifndef UNUSED_java_lang_String_lastIndexOf_3
 
460
JRIMethodID FAR methodID_java_lang_String_lastIndexOf_3 = JRIUninitialized;
 
461
#ifdef DEBUG
 
462
JRI_PUBLIC_API(jint)
 
463
java_lang_String_lastIndexOf_3(JRIEnv* env, struct java_lang_String* self, struct java_lang_String *a, jint b) {
 
464
        if (methodID_java_lang_String_lastIndexOf_3 == JRIUninitialized) {
 
465
                assert(!"Forgot to call use_java_lang_String(env) before calling method lastIndexOf (Ljava/lang/String;I)I");
 
466
        }
 
467
        return (jint)JRI_CallMethodInt(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_lastIndexOf_3, a, b);
 
468
}
 
469
#endif /* DEBUG */
 
470
#endif /* UNUSED_java_lang_String_lastIndexOf_3 */
 
471
 
 
472
#ifndef UNUSED_java_lang_String_substring
 
473
JRIMethodID FAR methodID_java_lang_String_substring = JRIUninitialized;
 
474
#ifdef DEBUG
 
475
JRI_PUBLIC_API(struct java_lang_String *)
 
476
java_lang_String_substring(JRIEnv* env, struct java_lang_String* self, jint a) {
 
477
        if (methodID_java_lang_String_substring == JRIUninitialized) {
 
478
                assert(!"Forgot to call use_java_lang_String(env) before calling method substring (I)Ljava/lang/String;");
 
479
        }
 
480
        return (struct java_lang_String *)JRI_CallMethod(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_substring, a);
 
481
}
 
482
#endif /* DEBUG */
 
483
#endif /* UNUSED_java_lang_String_substring */
 
484
 
 
485
#ifndef UNUSED_java_lang_String_substring_1
 
486
JRIMethodID FAR methodID_java_lang_String_substring_1 = JRIUninitialized;
 
487
#ifdef DEBUG
 
488
JRI_PUBLIC_API(struct java_lang_String *)
 
489
java_lang_String_substring_1(JRIEnv* env, struct java_lang_String* self, jint a, jint b) {
 
490
        if (methodID_java_lang_String_substring_1 == JRIUninitialized) {
 
491
                assert(!"Forgot to call use_java_lang_String(env) before calling method substring (II)Ljava/lang/String;");
 
492
        }
 
493
        return (struct java_lang_String *)JRI_CallMethod(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_substring_1, a, b);
 
494
}
 
495
#endif /* DEBUG */
 
496
#endif /* UNUSED_java_lang_String_substring_1 */
 
497
 
 
498
#ifndef UNUSED_java_lang_String_concat
 
499
JRIMethodID FAR methodID_java_lang_String_concat = JRIUninitialized;
 
500
#ifdef DEBUG
 
501
JRI_PUBLIC_API(struct java_lang_String *)
 
502
java_lang_String_concat(JRIEnv* env, struct java_lang_String* self, struct java_lang_String *a) {
 
503
        if (methodID_java_lang_String_concat == JRIUninitialized) {
 
504
                assert(!"Forgot to call use_java_lang_String(env) before calling method concat (Ljava/lang/String;)Ljava/lang/String;");
 
505
        }
 
506
        return (struct java_lang_String *)JRI_CallMethod(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_concat, a);
 
507
}
 
508
#endif /* DEBUG */
 
509
#endif /* UNUSED_java_lang_String_concat */
 
510
 
 
511
#ifndef UNUSED_java_lang_String_replace
 
512
JRIMethodID FAR methodID_java_lang_String_replace = JRIUninitialized;
 
513
#ifdef DEBUG
 
514
JRI_PUBLIC_API(struct java_lang_String *)
 
515
java_lang_String_replace(JRIEnv* env, struct java_lang_String* self, jchar a, jchar b) {
 
516
        if (methodID_java_lang_String_replace == JRIUninitialized) {
 
517
                assert(!"Forgot to call use_java_lang_String(env) before calling method replace (CC)Ljava/lang/String;");
 
518
        }
 
519
        return (struct java_lang_String *)JRI_CallMethod(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_replace, a, b);
 
520
}
 
521
#endif /* DEBUG */
 
522
#endif /* UNUSED_java_lang_String_replace */
 
523
 
 
524
#ifndef UNUSED_java_lang_String_toLowerCase
 
525
JRIMethodID FAR methodID_java_lang_String_toLowerCase = JRIUninitialized;
 
526
#ifdef DEBUG
 
527
JRI_PUBLIC_API(struct java_lang_String *)
 
528
java_lang_String_toLowerCase(JRIEnv* env, struct java_lang_String* self) {
 
529
        if (methodID_java_lang_String_toLowerCase == JRIUninitialized) {
 
530
                assert(!"Forgot to call use_java_lang_String(env) before calling method toLowerCase ()Ljava/lang/String;");
 
531
        }
 
532
        return (struct java_lang_String *)JRI_CallMethod(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_toLowerCase);
 
533
}
 
534
#endif /* DEBUG */
 
535
#endif /* UNUSED_java_lang_String_toLowerCase */
 
536
 
 
537
#ifndef UNUSED_java_lang_String_toUpperCase
 
538
JRIMethodID FAR methodID_java_lang_String_toUpperCase = JRIUninitialized;
 
539
#ifdef DEBUG
 
540
JRI_PUBLIC_API(struct java_lang_String *)
 
541
java_lang_String_toUpperCase(JRIEnv* env, struct java_lang_String* self) {
 
542
        if (methodID_java_lang_String_toUpperCase == JRIUninitialized) {
 
543
                assert(!"Forgot to call use_java_lang_String(env) before calling method toUpperCase ()Ljava/lang/String;");
 
544
        }
 
545
        return (struct java_lang_String *)JRI_CallMethod(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_toUpperCase);
 
546
}
 
547
#endif /* DEBUG */
 
548
#endif /* UNUSED_java_lang_String_toUpperCase */
 
549
 
 
550
#ifndef UNUSED_java_lang_String_trim
 
551
JRIMethodID FAR methodID_java_lang_String_trim = JRIUninitialized;
 
552
#ifdef DEBUG
 
553
JRI_PUBLIC_API(struct java_lang_String *)
 
554
java_lang_String_trim(JRIEnv* env, struct java_lang_String* self) {
 
555
        if (methodID_java_lang_String_trim == JRIUninitialized) {
 
556
                assert(!"Forgot to call use_java_lang_String(env) before calling method trim ()Ljava/lang/String;");
 
557
        }
 
558
        return (struct java_lang_String *)JRI_CallMethod(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_trim);
 
559
}
 
560
#endif /* DEBUG */
 
561
#endif /* UNUSED_java_lang_String_trim */
 
562
 
 
563
#ifndef UNUSED_java_lang_String_toString
 
564
JRIMethodID FAR methodID_java_lang_String_toString = JRIUninitialized;
 
565
#ifdef DEBUG
 
566
JRI_PUBLIC_API(struct java_lang_String *)
 
567
java_lang_String_toString(JRIEnv* env, struct java_lang_String* self) {
 
568
        if (methodID_java_lang_String_toString == JRIUninitialized) {
 
569
                assert(!"Forgot to call use_java_lang_String(env) before calling method toString ()Ljava/lang/String;");
 
570
        }
 
571
        return (struct java_lang_String *)JRI_CallMethod(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_toString);
 
572
}
 
573
#endif /* DEBUG */
 
574
#endif /* UNUSED_java_lang_String_toString */
 
575
 
 
576
#ifndef UNUSED_java_lang_String_toCharArray
 
577
JRIMethodID FAR methodID_java_lang_String_toCharArray = JRIUninitialized;
 
578
#ifdef DEBUG
 
579
JRI_PUBLIC_API(jref)
 
580
java_lang_String_toCharArray(JRIEnv* env, struct java_lang_String* self) {
 
581
        if (methodID_java_lang_String_toCharArray == JRIUninitialized) {
 
582
                assert(!"Forgot to call use_java_lang_String(env) before calling method toCharArray ()[C");
 
583
        }
 
584
        return (jref)JRI_CallMethod(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_toCharArray);
 
585
}
 
586
#endif /* DEBUG */
 
587
#endif /* UNUSED_java_lang_String_toCharArray */
 
588
 
 
589
#ifndef UNUSED_java_lang_String_valueOf
 
590
JRIMethodID FAR methodID_java_lang_String_valueOf = JRIUninitialized;
 
591
#ifdef DEBUG
 
592
JRI_PUBLIC_API(struct java_lang_String *)
 
593
java_lang_String_valueOf(JRIEnv* env, struct java_lang_Class* clazz, struct java_lang_Object *a) {
 
594
        if (methodID_java_lang_String_valueOf == JRIUninitialized) {
 
595
                assert(!"Forgot to call use_java_lang_String(env) before calling method valueOf (Ljava/lang/Object;)Ljava/lang/String;");
 
596
        }
 
597
        return (struct java_lang_String *)JRI_CallStaticMethod(env)(env, JRI_CallStaticMethod_op, clazz, methodID_java_lang_String_valueOf, a);
 
598
}
 
599
#endif /* DEBUG */
 
600
#endif /* UNUSED_java_lang_String_valueOf */
 
601
 
 
602
#ifndef UNUSED_java_lang_String_valueOf_1
 
603
JRIMethodID FAR methodID_java_lang_String_valueOf_1 = JRIUninitialized;
 
604
#ifdef DEBUG
 
605
JRI_PUBLIC_API(struct java_lang_String *)
 
606
java_lang_String_valueOf_1(JRIEnv* env, struct java_lang_Class* clazz, jcharArray a) {
 
607
        if (methodID_java_lang_String_valueOf_1 == JRIUninitialized) {
 
608
                assert(!"Forgot to call use_java_lang_String(env) before calling method valueOf ([C)Ljava/lang/String;");
 
609
        }
 
610
        return (struct java_lang_String *)JRI_CallStaticMethod(env)(env, JRI_CallStaticMethod_op, clazz, methodID_java_lang_String_valueOf_1, a);
 
611
}
 
612
#endif /* DEBUG */
 
613
#endif /* UNUSED_java_lang_String_valueOf_1 */
 
614
 
 
615
#ifndef UNUSED_java_lang_String_valueOf_2
 
616
JRIMethodID FAR methodID_java_lang_String_valueOf_2 = JRIUninitialized;
 
617
#ifdef DEBUG
 
618
JRI_PUBLIC_API(struct java_lang_String *)
 
619
java_lang_String_valueOf_2(JRIEnv* env, struct java_lang_Class* clazz, jcharArray a, jint b, jint c) {
 
620
        if (methodID_java_lang_String_valueOf_2 == JRIUninitialized) {
 
621
                assert(!"Forgot to call use_java_lang_String(env) before calling method valueOf ([CII)Ljava/lang/String;");
 
622
        }
 
623
        return (struct java_lang_String *)JRI_CallStaticMethod(env)(env, JRI_CallStaticMethod_op, clazz, methodID_java_lang_String_valueOf_2, a, b, c);
 
624
}
 
625
#endif /* DEBUG */
 
626
#endif /* UNUSED_java_lang_String_valueOf_2 */
 
627
 
 
628
#ifndef UNUSED_java_lang_String_copyValueOf
 
629
JRIMethodID FAR methodID_java_lang_String_copyValueOf = JRIUninitialized;
 
630
#ifdef DEBUG
 
631
JRI_PUBLIC_API(struct java_lang_String *)
 
632
java_lang_String_copyValueOf(JRIEnv* env, struct java_lang_Class* clazz, jcharArray a, jint b, jint c) {
 
633
        if (methodID_java_lang_String_copyValueOf == JRIUninitialized) {
 
634
                assert(!"Forgot to call use_java_lang_String(env) before calling method copyValueOf ([CII)Ljava/lang/String;");
 
635
        }
 
636
        return (struct java_lang_String *)JRI_CallStaticMethod(env)(env, JRI_CallStaticMethod_op, clazz, methodID_java_lang_String_copyValueOf, a, b, c);
 
637
}
 
638
#endif /* DEBUG */
 
639
#endif /* UNUSED_java_lang_String_copyValueOf */
 
640
 
 
641
#ifndef UNUSED_java_lang_String_copyValueOf_1
 
642
JRIMethodID FAR methodID_java_lang_String_copyValueOf_1 = JRIUninitialized;
 
643
#ifdef DEBUG
 
644
JRI_PUBLIC_API(struct java_lang_String *)
 
645
java_lang_String_copyValueOf_1(JRIEnv* env, struct java_lang_Class* clazz, jcharArray a) {
 
646
        if (methodID_java_lang_String_copyValueOf_1 == JRIUninitialized) {
 
647
                assert(!"Forgot to call use_java_lang_String(env) before calling method copyValueOf ([C)Ljava/lang/String;");
 
648
        }
 
649
        return (struct java_lang_String *)JRI_CallStaticMethod(env)(env, JRI_CallStaticMethod_op, clazz, methodID_java_lang_String_copyValueOf_1, a);
 
650
}
 
651
#endif /* DEBUG */
 
652
#endif /* UNUSED_java_lang_String_copyValueOf_1 */
 
653
 
 
654
#ifndef UNUSED_java_lang_String_valueOf_3
 
655
JRIMethodID FAR methodID_java_lang_String_valueOf_3 = JRIUninitialized;
 
656
#ifdef DEBUG
 
657
JRI_PUBLIC_API(struct java_lang_String *)
 
658
java_lang_String_valueOf_3(JRIEnv* env, struct java_lang_Class* clazz, jbool a) {
 
659
        if (methodID_java_lang_String_valueOf_3 == JRIUninitialized) {
 
660
                assert(!"Forgot to call use_java_lang_String(env) before calling method valueOf (Z)Ljava/lang/String;");
 
661
        }
 
662
        return (struct java_lang_String *)JRI_CallStaticMethod(env)(env, JRI_CallStaticMethod_op, clazz, methodID_java_lang_String_valueOf_3, a);
 
663
}
 
664
#endif /* DEBUG */
 
665
#endif /* UNUSED_java_lang_String_valueOf_3 */
 
666
 
 
667
#ifndef UNUSED_java_lang_String_valueOf_4
 
668
JRIMethodID FAR methodID_java_lang_String_valueOf_4 = JRIUninitialized;
 
669
#ifdef DEBUG
 
670
JRI_PUBLIC_API(struct java_lang_String *)
 
671
java_lang_String_valueOf_4(JRIEnv* env, struct java_lang_Class* clazz, jchar a) {
 
672
        if (methodID_java_lang_String_valueOf_4 == JRIUninitialized) {
 
673
                assert(!"Forgot to call use_java_lang_String(env) before calling method valueOf (C)Ljava/lang/String;");
 
674
        }
 
675
        return (struct java_lang_String *)JRI_CallStaticMethod(env)(env, JRI_CallStaticMethod_op, clazz, methodID_java_lang_String_valueOf_4, a);
 
676
}
 
677
#endif /* DEBUG */
 
678
#endif /* UNUSED_java_lang_String_valueOf_4 */
 
679
 
 
680
#ifndef UNUSED_java_lang_String_valueOf_5
 
681
JRIMethodID FAR methodID_java_lang_String_valueOf_5 = JRIUninitialized;
 
682
#ifdef DEBUG
 
683
JRI_PUBLIC_API(struct java_lang_String *)
 
684
java_lang_String_valueOf_5(JRIEnv* env, struct java_lang_Class* clazz, jint a) {
 
685
        if (methodID_java_lang_String_valueOf_5 == JRIUninitialized) {
 
686
                assert(!"Forgot to call use_java_lang_String(env) before calling method valueOf (I)Ljava/lang/String;");
 
687
        }
 
688
        return (struct java_lang_String *)JRI_CallStaticMethod(env)(env, JRI_CallStaticMethod_op, clazz, methodID_java_lang_String_valueOf_5, a);
 
689
}
 
690
#endif /* DEBUG */
 
691
#endif /* UNUSED_java_lang_String_valueOf_5 */
 
692
 
 
693
#ifndef UNUSED_java_lang_String_valueOf_6
 
694
JRIMethodID FAR methodID_java_lang_String_valueOf_6 = JRIUninitialized;
 
695
#ifdef DEBUG
 
696
JRI_PUBLIC_API(struct java_lang_String *)
 
697
java_lang_String_valueOf_6(JRIEnv* env, struct java_lang_Class* clazz, jlong a) {
 
698
        if (methodID_java_lang_String_valueOf_6 == JRIUninitialized) {
 
699
                assert(!"Forgot to call use_java_lang_String(env) before calling method valueOf (J)Ljava/lang/String;");
 
700
        }
 
701
        return (struct java_lang_String *)JRI_CallStaticMethod(env)(env, JRI_CallStaticMethod_op, clazz, methodID_java_lang_String_valueOf_6, a);
 
702
}
 
703
#endif /* DEBUG */
 
704
#endif /* UNUSED_java_lang_String_valueOf_6 */
 
705
 
 
706
#ifndef UNUSED_java_lang_String_valueOf_7
 
707
JRIMethodID FAR methodID_java_lang_String_valueOf_7 = JRIUninitialized;
 
708
#ifdef DEBUG
 
709
JRI_PUBLIC_API(struct java_lang_String *)
 
710
java_lang_String_valueOf_7(JRIEnv* env, struct java_lang_Class* clazz, jfloat a) {
 
711
        if (methodID_java_lang_String_valueOf_7 == JRIUninitialized) {
 
712
                assert(!"Forgot to call use_java_lang_String(env) before calling method valueOf (F)Ljava/lang/String;");
 
713
        }
 
714
        return (struct java_lang_String *)JRI_CallStaticMethod(env)(env, JRI_CallStaticMethod_op, clazz, methodID_java_lang_String_valueOf_7, a);
 
715
}
 
716
#endif /* DEBUG */
 
717
#endif /* UNUSED_java_lang_String_valueOf_7 */
 
718
 
 
719
#ifndef UNUSED_java_lang_String_valueOf_8
 
720
JRIMethodID FAR methodID_java_lang_String_valueOf_8 = JRIUninitialized;
 
721
#ifdef DEBUG
 
722
JRI_PUBLIC_API(struct java_lang_String *)
 
723
java_lang_String_valueOf_8(JRIEnv* env, struct java_lang_Class* clazz, jdouble a) {
 
724
        if (methodID_java_lang_String_valueOf_8 == JRIUninitialized) {
 
725
                assert(!"Forgot to call use_java_lang_String(env) before calling method valueOf (D)Ljava/lang/String;");
 
726
        }
 
727
        return (struct java_lang_String *)JRI_CallStaticMethod(env)(env, JRI_CallStaticMethod_op, clazz, methodID_java_lang_String_valueOf_8, a);
 
728
}
 
729
#endif /* DEBUG */
 
730
#endif /* UNUSED_java_lang_String_valueOf_8 */
 
731
 
 
732
#ifndef UNUSED_java_lang_String_intern
 
733
JRIMethodID FAR methodID_java_lang_String_intern = JRIUninitialized;
 
734
#ifdef DEBUG
 
735
JRI_PUBLIC_API(struct java_lang_String *)
 
736
java_lang_String_intern(JRIEnv* env, struct java_lang_String* self) {
 
737
        if (methodID_java_lang_String_intern == JRIUninitialized) {
 
738
                assert(!"Forgot to call use_java_lang_String(env) before calling method intern ()Ljava/lang/String;");
 
739
        }
 
740
        return (struct java_lang_String *)JRI_CallMethod(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_intern);
 
741
}
 
742
#endif /* DEBUG */
 
743
#endif /* UNUSED_java_lang_String_intern */
 
744
 
 
745
#ifndef UNUSED_java_lang_String_utfLength
 
746
JRIMethodID FAR methodID_java_lang_String_utfLength = JRIUninitialized;
 
747
#ifdef DEBUG
 
748
JRI_PUBLIC_API(jint)
 
749
java_lang_String_utfLength(JRIEnv* env, struct java_lang_String* self) {
 
750
        if (methodID_java_lang_String_utfLength == JRIUninitialized) {
 
751
                assert(!"Forgot to call use_java_lang_String(env) before calling method utfLength ()I");
 
752
        }
 
753
        return (jint)JRI_CallMethodInt(env)(env, JRI_CallMethod_op, self, methodID_java_lang_String_utfLength);
 
754
}
 
755
#endif /* DEBUG */
 
756
#endif /* UNUSED_java_lang_String_utfLength */
 
757
 
 
758
#ifndef UNUSED_use_java_lang_String
 
759
 
 
760
static jglobal _globalclass_java_lang_String = NULL;
 
761
 
 
762
JRI_PUBLIC_API(struct java_lang_Class*)
 
763
use_java_lang_String(JRIEnv* env)
 
764
{
 
765
        if (_globalclass_java_lang_String == NULL) {
 
766
                struct java_lang_Class* clazz = JRI_FindClass(env, classname_java_lang_String);
 
767
                if (clazz == NULL) {
 
768
                        JRI_ThrowNew(env, JRI_FindClass(env, "java/lang/ClassNotFoundException"), classname_java_lang_String);
 
769
                        return NULL;
 
770
                }
 
771
                use_java_lang_String_value(env, clazz);
 
772
                use_java_lang_String_offset(env, clazz);
 
773
                use_java_lang_String_count(env, clazz);
 
774
                use_java_lang_String_InternSet(env, clazz);
 
775
                use_java_lang_String_new(env, clazz);
 
776
                use_java_lang_String_new_1(env, clazz);
 
777
                use_java_lang_String_new_2(env, clazz);
 
778
                use_java_lang_String_new_3(env, clazz);
 
779
                use_java_lang_String_new_4(env, clazz);
 
780
                use_java_lang_String_new_5(env, clazz);
 
781
                use_java_lang_String_new_6(env, clazz);
 
782
                use_java_lang_String_new_7(env, clazz);
 
783
                use_java_lang_String_length(env, clazz);
 
784
                use_java_lang_String_charAt(env, clazz);
 
785
                use_java_lang_String_getChars(env, clazz);
 
786
                use_java_lang_String_getBytes(env, clazz);
 
787
                use_java_lang_String_equals(env, clazz);
 
788
                use_java_lang_String_equalsIgnoreCase(env, clazz);
 
789
                use_java_lang_String_compareTo(env, clazz);
 
790
                use_java_lang_String_regionMatches(env, clazz);
 
791
                use_java_lang_String_regionMatches_1(env, clazz);
 
792
                use_java_lang_String_startsWith(env, clazz);
 
793
                use_java_lang_String_startsWith_1(env, clazz);
 
794
                use_java_lang_String_endsWith(env, clazz);
 
795
                use_java_lang_String_hashCode(env, clazz);
 
796
                use_java_lang_String_indexOf(env, clazz);
 
797
                use_java_lang_String_indexOf_1(env, clazz);
 
798
                use_java_lang_String_lastIndexOf(env, clazz);
 
799
                use_java_lang_String_lastIndexOf_1(env, clazz);
 
800
                use_java_lang_String_indexOf_2(env, clazz);
 
801
                use_java_lang_String_indexOf_3(env, clazz);
 
802
                use_java_lang_String_lastIndexOf_2(env, clazz);
 
803
                use_java_lang_String_lastIndexOf_3(env, clazz);
 
804
                use_java_lang_String_substring(env, clazz);
 
805
                use_java_lang_String_substring_1(env, clazz);
 
806
                use_java_lang_String_concat(env, clazz);
 
807
                use_java_lang_String_replace(env, clazz);
 
808
                use_java_lang_String_toLowerCase(env, clazz);
 
809
                use_java_lang_String_toUpperCase(env, clazz);
 
810
                use_java_lang_String_trim(env, clazz);
 
811
                use_java_lang_String_toString(env, clazz);
 
812
                use_java_lang_String_toCharArray(env, clazz);
 
813
                use_java_lang_String_valueOf(env, clazz);
 
814
                use_java_lang_String_valueOf_1(env, clazz);
 
815
                use_java_lang_String_valueOf_2(env, clazz);
 
816
                use_java_lang_String_copyValueOf(env, clazz);
 
817
                use_java_lang_String_copyValueOf_1(env, clazz);
 
818
                use_java_lang_String_valueOf_3(env, clazz);
 
819
                use_java_lang_String_valueOf_4(env, clazz);
 
820
                use_java_lang_String_valueOf_5(env, clazz);
 
821
                use_java_lang_String_valueOf_6(env, clazz);
 
822
                use_java_lang_String_valueOf_7(env, clazz);
 
823
                use_java_lang_String_valueOf_8(env, clazz);
 
824
                use_java_lang_String_intern(env, clazz);
 
825
                use_java_lang_String_utfLength(env, clazz);
 
826
                _globalclass_java_lang_String = JRI_NewGlobalRef(env, clazz);
 
827
                return clazz;
 
828
        }
 
829
        else {
 
830
                return JRI_GetGlobalRef(env, _globalclass_java_lang_String);
 
831
        }
 
832
}
 
833
 
 
834
JRI_PUBLIC_API(void)
 
835
unuse_java_lang_String(JRIEnv* env)
 
836
{
 
837
        if (_globalclass_java_lang_String != NULL) {
 
838
                struct java_lang_Class* clazz = JRI_GetGlobalRef(env, _globalclass_java_lang_String);
 
839
                unuse_java_lang_String_value(env, clazz);
 
840
                unuse_java_lang_String_offset(env, clazz);
 
841
                unuse_java_lang_String_count(env, clazz);
 
842
                unuse_java_lang_String_InternSet(env, clazz);
 
843
                unuse_java_lang_String_new(env, clazz);
 
844
                unuse_java_lang_String_new_1(env, clazz);
 
845
                unuse_java_lang_String_new_2(env, clazz);
 
846
                unuse_java_lang_String_new_3(env, clazz);
 
847
                unuse_java_lang_String_new_4(env, clazz);
 
848
                unuse_java_lang_String_new_5(env, clazz);
 
849
                unuse_java_lang_String_new_6(env, clazz);
 
850
                unuse_java_lang_String_new_7(env, clazz);
 
851
                unuse_java_lang_String_length(env, clazz);
 
852
                unuse_java_lang_String_charAt(env, clazz);
 
853
                unuse_java_lang_String_getChars(env, clazz);
 
854
                unuse_java_lang_String_getBytes(env, clazz);
 
855
                unuse_java_lang_String_equals(env, clazz);
 
856
                unuse_java_lang_String_equalsIgnoreCase(env, clazz);
 
857
                unuse_java_lang_String_compareTo(env, clazz);
 
858
                unuse_java_lang_String_regionMatches(env, clazz);
 
859
                unuse_java_lang_String_regionMatches_1(env, clazz);
 
860
                unuse_java_lang_String_startsWith(env, clazz);
 
861
                unuse_java_lang_String_startsWith_1(env, clazz);
 
862
                unuse_java_lang_String_endsWith(env, clazz);
 
863
                unuse_java_lang_String_hashCode(env, clazz);
 
864
                unuse_java_lang_String_indexOf(env, clazz);
 
865
                unuse_java_lang_String_indexOf_1(env, clazz);
 
866
                unuse_java_lang_String_lastIndexOf(env, clazz);
 
867
                unuse_java_lang_String_lastIndexOf_1(env, clazz);
 
868
                unuse_java_lang_String_indexOf_2(env, clazz);
 
869
                unuse_java_lang_String_indexOf_3(env, clazz);
 
870
                unuse_java_lang_String_lastIndexOf_2(env, clazz);
 
871
                unuse_java_lang_String_lastIndexOf_3(env, clazz);
 
872
                unuse_java_lang_String_substring(env, clazz);
 
873
                unuse_java_lang_String_substring_1(env, clazz);
 
874
                unuse_java_lang_String_concat(env, clazz);
 
875
                unuse_java_lang_String_replace(env, clazz);
 
876
                unuse_java_lang_String_toLowerCase(env, clazz);
 
877
                unuse_java_lang_String_toUpperCase(env, clazz);
 
878
                unuse_java_lang_String_trim(env, clazz);
 
879
                unuse_java_lang_String_toString(env, clazz);
 
880
                unuse_java_lang_String_toCharArray(env, clazz);
 
881
                unuse_java_lang_String_valueOf(env, clazz);
 
882
                unuse_java_lang_String_valueOf_1(env, clazz);
 
883
                unuse_java_lang_String_valueOf_2(env, clazz);
 
884
                unuse_java_lang_String_copyValueOf(env, clazz);
 
885
                unuse_java_lang_String_copyValueOf_1(env, clazz);
 
886
                unuse_java_lang_String_valueOf_3(env, clazz);
 
887
                unuse_java_lang_String_valueOf_4(env, clazz);
 
888
                unuse_java_lang_String_valueOf_5(env, clazz);
 
889
                unuse_java_lang_String_valueOf_6(env, clazz);
 
890
                unuse_java_lang_String_valueOf_7(env, clazz);
 
891
                unuse_java_lang_String_valueOf_8(env, clazz);
 
892
                unuse_java_lang_String_intern(env, clazz);
 
893
                unuse_java_lang_String_utfLength(env, clazz);
 
894
                JRI_DisposeGlobalRef(env, _globalclass_java_lang_String);
 
895
                _globalclass_java_lang_String = NULL;
 
896
                clazz = NULL;   /* prevent unused variable 'clazz' warning */
 
897
        }
 
898
}
 
899
 
 
900
#endif /* UNUSED_use_java_lang_String */
 
901
 
 
902
#ifdef _implementing_java_lang_String
 
903
 
 
904
JRI_PUBLIC_API(struct java_lang_Class*)
 
905
register_java_lang_String(JRIEnv* env)
 
906
{
 
907
        char* nativeNamesAndSigs[] = {
 
908
                NULL
 
909
        };
 
910
        void* nativeProcs[] = {
 
911
                NULL
 
912
        };
 
913
        struct java_lang_Class* clazz = JRI_FindClass(env, classname_java_lang_String);
 
914
        if (clazz == NULL) {
 
915
                JRI_ThrowNew(env, JRI_FindClass(env, "java/lang/ClassNotFoundException"), classname_java_lang_String);
 
916
                return NULL;
 
917
        }
 
918
        JRI_RegisterNatives(env, clazz, nativeNamesAndSigs, nativeProcs);
 
919
        use_java_lang_String(env);
 
920
        return clazz;
 
921
}
 
922
 
 
923
JRI_PUBLIC_API(void)
 
924
unregister_java_lang_String(JRIEnv* env)
 
925
{
 
926
        struct java_lang_Class* clazz = JRI_FindClass(env, classname_java_lang_String);
 
927
        JRI_UnregisterNatives(env, clazz);
 
928
        unuse_java_lang_String(env);
 
929
}
 
930
 
 
931
#endif /* _implementing_java_lang_String */
 
932
 
 
933
/* These stub routines are generated for compatibility with the JDK: */
 
934
 
 
935
#ifndef NO_JDK
 
936
 
 
937
#endif /* NO_JDK */
 
938