Commit | Line | Data |
---|---|---|
b83c0eaa GS |
1 | JavaVM * T_JPTROBJ |
2 | JNINativeMethod * T_JPTROBJ | |
3 | const char * T_PV | |
4 | const jbyte * T_JMEM | |
5 | const jchar * T_JMEM | |
6 | jarray T_JPTROBJ | |
7 | jboolean T_IV | |
8 | jboolean * T_JMEM | |
9 | jbooleanArray T_JPTROBJ | |
10 | jbyte T_IV | |
11 | jbyte * T_JMEM | |
12 | jbyteArray T_JPTROBJ | |
13 | jchar T_IV | |
14 | jchar * T_JMEM | |
15 | jcharArray T_JPTROBJ | |
16 | jclass T_JPTROBJ | |
17 | jdouble T_NV | |
18 | jdouble * T_JMEM | |
19 | jdoubleArray T_JPTROBJ | |
20 | jfieldID T_JIDSIG | |
21 | jfloat T_NV | |
22 | jfloat * T_JMEM | |
23 | jfloatArray T_JPTROBJ | |
24 | jint T_IV | |
25 | jint * T_JMEM | |
26 | jintArray T_JPTROBJ | |
27 | jlong T_NV | |
28 | jlong * T_JMEM | |
29 | jlongArray T_JPTROBJ | |
30 | jmethodID T_JIDSIG | |
31 | jobject T_JPTROBJ | |
32 | jobjectArray T_JPTROBJ | |
33 | jshort T_IV | |
34 | jshort * T_JMEM | |
35 | jshortArray T_JPTROBJ | |
36 | jsize T_IV | |
37 | jstring T_JSTRING | |
38 | jthrowable T_JPTROBJ | |
39 | jvalue * T_JVALUELIST | |
40 | ||
41 | INPUT | |
42 | T_JMEM | |
43 | { | |
44 | $var = ($type)SvPV($arg,tmplen); | |
45 | ${var}_len_ = (jsize) tmplen / sizeof(${subtype}); | |
46 | } | |
47 | T_JSTRING | |
48 | if (SvROK($arg)) { | |
49 | $var = ($type)(void*)SvIV(SvRV($arg)); | |
50 | } | |
51 | else | |
52 | $var = ($type)env->NewStringUTF((char *) SvPV($arg,PL_na)) | |
53 | T_JVALUELIST | |
54 | if (SvROK($arg)) { | |
55 | AV* av = (AV*)SvRV($arg); | |
56 | if (SvTYPE(av) == SVt_PVAV) { | |
57 | I32 maxarg = AvFILL(av) + 1; | |
58 | $var = makeargs(sig, AvARRAY(av), maxarg); | |
59 | } | |
60 | else | |
61 | croak(\"$var is not an array reference\"); | |
62 | } | |
63 | else | |
64 | croak(\"$var is not a reference\") | |
65 | T_JIDSIG | |
66 | { | |
67 | $var = ($type)SvIV($arg); | |
68 | sig = (char*)SvPV($arg,PL_na); | |
69 | } | |
70 | T_JPTROBJ | |
71 | if (SvROK($arg) && SvOBJECT(SvRV($arg))) { | |
72 | IV tmp = SvIV((SV*)SvRV($arg)); | |
73 | $var = ($type) tmp; | |
74 | } | |
75 | else | |
76 | croak(\"$var is not of type ${ntype}\") | |
77 | ||
78 | OUTPUT | |
79 | T_JMEM | |
80 | sv_setpvn((SV*)$arg, (char*)$var, (STRLEN)${var}_len_ * sizeof(${subtype})); | |
81 | T_JSTRING | |
82 | { | |
83 | static HV* ${var}_stashhv_ = 0; | |
84 | if (!${var}_stashhv_) | |
85 | ${var}_stashhv_ = gv_stashpv("java::lang::String", TRUE); | |
86 | ||
87 | sv_bless( | |
88 | sv_setref_iv($arg, Nullch, (IV)(void*)${var}), | |
89 | ${var}_stashhv_); | |
90 | ||
91 | } | |
92 | T_JIDSIG | |
93 | sv_setiv($arg, (IV)(void*)$var); | |
94 | sv_setpv($arg, (char*)sig); | |
95 | SvIOK_on($arg); | |
96 | T_JPTROBJ | |
97 | sv_setref_pv($arg, \"${ntype}\", (void*)$var); | |
98 | ||
99 | # basic C types | |
100 | # int T_IV | |
101 | # unsigned T_IV | |
102 | # unsigned int T_IV | |
103 | # long T_IV | |
104 | # unsigned long T_IV | |
105 | # short T_IV | |
106 | # unsigned short T_IV | |
107 | # char T_CHAR | |
108 | # unsigned char T_U_CHAR | |
109 | # char * T_PV | |
110 | # unsigned char * T_PV | |
111 | # caddr_t T_PV | |
112 | # wchar_t * T_PV | |
113 | # wchar_t T_IV | |
114 | # bool_t T_IV | |
115 | # size_t T_IV | |
116 | # ssize_t T_IV | |
117 | # time_t T_NV | |
118 | # unsigned long * T_OPAQUEPTR | |
119 | # char ** T_PACKED | |
120 | # void * T_PTR | |
121 | # Time_t * T_PV | |
122 | # SV * T_SV | |
123 | # SVREF T_SVREF | |
124 | # AV * T_AVREF | |
125 | # HV * T_HVREF | |
126 | # CV * T_CVREF | |
127 | # | |
128 | # IV T_IV | |
129 | # I32 T_IV | |
130 | # I16 T_IV | |
131 | # I8 T_IV | |
132 | # U32 T_U_LONG | |
133 | # U16 T_U_SHORT | |
134 | # U8 T_IV | |
135 | # Result T_U_CHAR | |
136 | # Boolean T_IV | |
137 | # double T_DOUBLE | |
138 | # SysRet T_SYSRET | |
139 | # SysRetLong T_SYSRET | |
140 | # FILE * T_IN | |
141 | # FileHandle T_PTROBJ | |
142 | # InputStream T_IN | |
143 | # InOutStream T_INOUT | |
144 | # OutputStream T_OUT | |
145 | # bool T_BOOL | |
146 | # | |
147 | ############################################################################# | |
148 | # INPUT | |
149 | # T_SV | |
150 | # $var = $arg | |
151 | # T_SVREF | |
152 | # if (sv_isa($arg, \"${ntype}\")) | |
153 | # $var = (SV*)SvRV($arg); | |
154 | # else | |
155 | # croak(\"$var is not of type ${ntype}\") | |
156 | # T_AVREF | |
157 | # if (sv_isa($arg, \"${ntype}\")) | |
158 | # $var = (AV*)SvRV($arg); | |
159 | # else | |
160 | # croak(\"$var is not of type ${ntype}\") | |
161 | # T_HVREF | |
162 | # if (sv_isa($arg, \"${ntype}\")) | |
163 | # $var = (HV*)SvRV($arg); | |
164 | # else | |
165 | # croak(\"$var is not of type ${ntype}\") | |
166 | # T_CVREF | |
167 | # if (sv_isa($arg, \"${ntype}\")) | |
168 | # $var = (CV*)SvRV($arg); | |
169 | # else | |
170 | # croak(\"$var is not of type ${ntype}\") | |
171 | # T_SYSRET | |
172 | # $var NOT IMPLEMENTED | |
173 | # T_IV | |
174 | # $var = ($type)SvIV($arg) | |
175 | # T_INT | |
176 | # $var = (int)SvIV($arg) | |
177 | # T_ENUM | |
178 | # $var = ($type)SvIV($arg) | |
179 | # T_BOOL | |
180 | # $var = (int)SvIV($arg) | |
181 | # T_U_INT | |
182 | # $var = (unsigned int)SvIV($arg) | |
183 | # T_SHORT | |
184 | # $var = (short)SvIV($arg) | |
185 | # T_U_SHORT | |
186 | # $var = (unsigned short)SvIV($arg) | |
187 | # T_LONG | |
188 | # $var = (long)SvIV($arg) | |
189 | # T_U_LONG | |
190 | # $var = (unsigned long)SvIV($arg) | |
191 | # T_CHAR | |
192 | # $var = (char)*SvPV($arg,PL_na) | |
193 | # T_U_CHAR | |
194 | # $var = (unsigned char)SvIV($arg) | |
195 | # T_FLOAT | |
196 | # $var = (float)SvNV($arg) | |
197 | # T_NV | |
198 | # $var = ($type)SvNV($arg) | |
199 | # T_DOUBLE | |
200 | # $var = (double)SvNV($arg) | |
201 | # T_PV | |
202 | # $var = ($type)SvPV($arg,PL_na) | |
203 | # T_PTR | |
204 | # $var = ($type)SvIV($arg) | |
205 | # T_PTRREF | |
206 | # if (SvROK($arg)) { | |
207 | # IV tmp = SvIV((SV*)SvRV($arg)); | |
208 | # $var = ($type) tmp; | |
209 | # } | |
210 | # else | |
211 | # croak(\"$var is not a reference\") | |
212 | # T_REF_IV_REF | |
213 | # if (sv_isa($arg, \"${type}\")) { | |
214 | # IV tmp = SvIV((SV*)SvRV($arg)); | |
215 | # $var = *($type *) tmp; | |
216 | # } | |
217 | # else | |
218 | # croak(\"$var is not of type ${ntype}\") | |
219 | # T_REF_IV_PTR | |
220 | # if (sv_isa($arg, \"${type}\")) { | |
221 | # IV tmp = SvIV((SV*)SvRV($arg)); | |
222 | # $var = ($type) tmp; | |
223 | # } | |
224 | # else | |
225 | # croak(\"$var is not of type ${ntype}\") | |
226 | # T_PTROBJ | |
227 | # if (sv_derived_from($arg, \"${ntype}\")) { | |
228 | # IV tmp = SvIV((SV*)SvRV($arg)); | |
229 | # $var = ($type) tmp; | |
230 | # } | |
231 | # else | |
232 | # croak(\"$var is not of type ${ntype}\") | |
233 | # T_PTRDESC | |
234 | # if (sv_isa($arg, \"${ntype}\")) { | |
235 | # IV tmp = SvIV((SV*)SvRV($arg)); | |
236 | # ${type}_desc = (\U${type}_DESC\E*) tmp; | |
237 | # $var = ${type}_desc->ptr; | |
238 | # } | |
239 | # else | |
240 | # croak(\"$var is not of type ${ntype}\") | |
241 | # T_REFREF | |
242 | # if (SvROK($arg)) { | |
243 | # IV tmp = SvIV((SV*)SvRV($arg)); | |
244 | # $var = *($type) tmp; | |
245 | # } | |
246 | # else | |
247 | # croak(\"$var is not a reference\") | |
248 | # T_REFOBJ | |
249 | # if (sv_isa($arg, \"${ntype}\")) { | |
250 | # IV tmp = SvIV((SV*)SvRV($arg)); | |
251 | # $var = *($type) tmp; | |
252 | # } | |
253 | # else | |
254 | # croak(\"$var is not of type ${ntype}\") | |
255 | # T_OPAQUE | |
256 | # $var NOT IMPLEMENTED | |
257 | # T_OPAQUEPTR | |
258 | # $var = ($type)SvPV($arg,PL_na) | |
259 | # T_PACKED | |
260 | # $var = XS_unpack_$ntype($arg) | |
261 | # T_PACKEDARRAY | |
262 | # $var = XS_unpack_$ntype($arg) | |
263 | # T_CALLBACK | |
264 | # $var = make_perl_cb_$type($arg) | |
265 | # T_ARRAY | |
266 | # $var = $ntype(items -= $argoff); | |
267 | # U32 ix_$var = $argoff; | |
268 | # while (items--) { | |
269 | # DO_ARRAY_ELEM; | |
270 | # } | |
271 | # T_IN | |
272 | # $var = IoIFP(sv_2io($arg)) | |
273 | # T_INOUT | |
274 | # $var = IoIFP(sv_2io($arg)) | |
275 | # T_OUT | |
276 | # $var = IoOFP(sv_2io($arg)) | |
277 | ############################################################################## | |
278 | # OUTPUT | |
279 | # T_SV | |
280 | # $arg = $var; | |
281 | # T_SVREF | |
282 | # $arg = newRV((SV*)$var); | |
283 | # T_AVREF | |
284 | # $arg = newRV((SV*)$var); | |
285 | # T_HVREF | |
286 | # $arg = newRV((SV*)$var); | |
287 | # T_CVREF | |
288 | # $arg = newRV((SV*)$var); | |
289 | # T_IV | |
290 | # sv_setiv($arg, (IV)$var); | |
291 | # T_INT | |
292 | # sv_setiv($arg, (IV)$var); | |
293 | # T_SYSRET | |
294 | # if ($var != -1) { | |
295 | # if ($var == 0) | |
296 | # sv_setpvn($arg, "0 but true", 10); | |
297 | # else | |
298 | # sv_setiv($arg, (IV)$var); | |
299 | # } | |
300 | # T_ENUM | |
301 | # sv_setiv($arg, (IV)$var); | |
302 | # T_BOOL | |
303 | # $arg = boolSV($var); | |
304 | # T_U_INT | |
305 | # sv_setiv($arg, (IV)$var); | |
306 | # T_SHORT | |
307 | # sv_setiv($arg, (IV)$var); | |
308 | # T_U_SHORT | |
309 | # sv_setiv($arg, (IV)$var); | |
310 | # T_LONG | |
311 | # sv_setiv($arg, (IV)$var); | |
312 | # T_U_LONG | |
313 | # sv_setiv($arg, (IV)$var); | |
314 | # T_CHAR | |
315 | # sv_setpvn($arg, (char *)&$var, 1); | |
316 | # T_U_CHAR | |
317 | # sv_setiv($arg, (IV)$var); | |
318 | # T_FLOAT | |
319 | # sv_setnv($arg, (double)$var); | |
320 | # T_NV | |
321 | # sv_setnv($arg, (double)$var); | |
322 | # T_DOUBLE | |
323 | # sv_setnv($arg, (double)$var); | |
324 | # T_PV | |
325 | # sv_setpv((SV*)$arg, $var); | |
326 | # T_PTR | |
327 | # sv_setiv($arg, (IV)$var); | |
328 | # T_PTRREF | |
329 | # sv_setref_pv($arg, Nullch, (void*)$var); | |
330 | # T_REF_IV_REF | |
331 | # sv_setref_pv($arg, \"${ntype}\", (void*)new $ntype($var)); | |
332 | # T_REF_IV_PTR | |
333 | # sv_setref_pv($arg, \"${ntype}\", (void*)$var); | |
334 | # T_PTROBJ | |
335 | # sv_setref_pv($arg, \"${ntype}\", (void*)$var); | |
336 | # T_PTRDESC | |
337 | # sv_setref_pv($arg, \"${ntype}\", (void*)new\U${type}_DESC\E($var)); | |
338 | # T_REFREF | |
339 | # sv_setrefref($arg, \"${ntype}\", XS_service_$ntype, | |
340 | # ($var ? (void*)new $ntype($var) : 0)); | |
341 | # T_REFOBJ | |
342 | # NOT IMPLEMENTED | |
343 | # T_OPAQUE | |
344 | # sv_setpvn($arg, (char *)&$var, sizeof($var)); | |
345 | # T_OPAQUEPTR | |
346 | # sv_setpvn($arg, (char *)$var, sizeof(*$var)), XFree((char *)$var); | |
347 | # T_PACKED | |
348 | # XS_pack_$ntype($arg, $var); | |
349 | # T_PACKEDARRAY | |
350 | # XS_pack_$ntype($arg, $var, count_$ntype); | |
351 | # T_DATAUNIT | |
352 | # sv_setpvn($arg, $var.chp(), $var.size()); | |
353 | # T_CALLBACK | |
354 | # sv_setpvn($arg, $var.context.value().chp(), | |
355 | # $var.context.value().size()); | |
356 | # T_ARRAY | |
357 | # ST_EXTEND($var.size); | |
358 | # for (U32 ix_$var = 0; ix_$var < $var.size; ix_$var++) { | |
359 | # ST(ix_$var) = sv_newmortal(); | |
360 | # DO_ARRAY_ELEM | |
361 | # } | |
362 | # sp += $var.size - 1; | |
363 | # T_IN | |
364 | # { | |
365 | # GV *gv = newGVgen("$Package"); | |
366 | # if ( do_open(gv, "<&", 2, FALSE, 0, 0, $var) ) | |
367 | # sv_setsv($arg, sv_bless(newRV((SV*)gv), gv_stashpv("$Package",1))); | |
368 | # else | |
369 | # $arg = &PL_sv_undef; | |
370 | # } | |
371 | # T_INOUT | |
372 | # { | |
373 | # GV *gv = newGVgen("$Package"); | |
374 | # if ( do_open(gv, "+<&", 3, FALSE, 0, 0, $var) ) | |
375 | # sv_setsv($arg, sv_bless(newRV((SV*)gv), gv_stashpv("$Package",1))); | |
376 | # else | |
377 | # $arg = &PL_sv_undef; | |
378 | # } | |
379 | # T_OUT | |
380 | # { | |
381 | # GV *gv = newGVgen("$Package"); | |
382 | # if ( do_open(gv, "+>&", 3, FALSE, 0, 0, $var) ) | |
383 | # sv_setsv($arg, sv_bless(newRV((SV*)gv), gv_stashpv("$Package",1))); | |
384 | # else | |
385 | # $arg = &PL_sv_undef; | |
386 | # } |