jpl/JNI/typemap.gcc

   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(env, (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 #               }