home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / perl560.zip / jpl / JNI / typemap.gcc < prev    next >
Text File  |  1999-09-14  |  9KB  |  387 lines
  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. #        }
  387.