PageRenderTime 41ms CodeModel.GetById 16ms RepoModel.GetById 0ms app.codeStats 0ms

/trunk/Lib/perl5/reference.i

#
Swig | 261 lines | 201 code | 12 blank | 48 comment | 0 complexity | 4b77c4df88bcab349b10528b5d593e24 MD5 | raw file
Possible License(s): LGPL-2.1, Cube, GPL-3.0, 0BSD, GPL-2.0
  1. /* -----------------------------------------------------------------------------
  2. * reference.i
  3. *
  4. * Accept Perl references as pointers
  5. * ----------------------------------------------------------------------------- */
  6. /*
  7. The following methods make Perl references work like simple C
  8. pointers. References can only be used for simple input/output
  9. values, not C arrays however. It should also be noted that
  10. REFERENCES are specific to Perl and not supported in other
  11. scripting languages at this time.
  12. int *REFERENCE
  13. short *REFERENCE
  14. long *REFERENCE
  15. unsigned int *REFERENCE
  16. unsigned short *REFERENCE
  17. unsigned long *REFERENCE
  18. unsigned char *REFERENCE
  19. float *REFERENCE
  20. double *REFERENCE
  21. For example, suppose you were trying to wrap the following function :
  22. void neg(double *x) {
  23. *x = -(*x);
  24. }
  25. You could wrap it with SWIG as follows :
  26. %include reference.i
  27. void neg(double *REFERENCE);
  28. or you can use the %apply directive :
  29. %include reference.i
  30. %apply double *REFERENCE { double *x };
  31. void neg(double *x);
  32. Unlike the INOUT mapping described in typemaps.i, this approach directly
  33. modifies the value of a Perl reference. Thus, you could use it
  34. as follows :
  35. $x = 3;
  36. neg(\$x);
  37. print "$x\n"; # Should print out -3.
  38. */
  39. %typemap(in) double *REFERENCE (double dvalue), double &REFERENCE(double dvalue)
  40. {
  41. SV *tempsv;
  42. if (!SvROK($input)) {
  43. SWIG_croak("expected a reference");
  44. }
  45. tempsv = SvRV($input);
  46. if ((!SvNOK(tempsv)) && (!SvIOK(tempsv))) {
  47. printf("Received %d\n", SvTYPE(tempsv));
  48. SWIG_croak("Expected a double reference.");
  49. }
  50. dvalue = SvNV(tempsv);
  51. $1 = &dvalue;
  52. }
  53. %typemap(in) float *REFERENCE (float dvalue), float &REFERENCE(float dvalue)
  54. {
  55. SV *tempsv;
  56. if (!SvROK($input)) {
  57. SWIG_croak("expected a reference");
  58. }
  59. tempsv = SvRV($input);
  60. if ((!SvNOK(tempsv)) && (!SvIOK(tempsv))) {
  61. SWIG_croak("expected a double reference");
  62. }
  63. dvalue = (float) SvNV(tempsv);
  64. $1 = &dvalue;
  65. }
  66. %typemap(in) int *REFERENCE (int dvalue), int &REFERENCE (int dvalue)
  67. {
  68. SV *tempsv;
  69. if (!SvROK($input)) {
  70. SWIG_croak("expected a reference");
  71. }
  72. tempsv = SvRV($input);
  73. if (!SvIOK(tempsv)) {
  74. SWIG_croak("expected a integer reference");
  75. }
  76. dvalue = SvIV(tempsv);
  77. $1 = &dvalue;
  78. }
  79. %typemap(in) short *REFERENCE (short dvalue), short &REFERENCE(short dvalue)
  80. {
  81. SV *tempsv;
  82. if (!SvROK($input)) {
  83. SWIG_croak("expected a reference");
  84. }
  85. tempsv = SvRV($input);
  86. if (!SvIOK(tempsv)) {
  87. SWIG_croak("expected a integer reference");
  88. }
  89. dvalue = (short) SvIV(tempsv);
  90. $1 = &dvalue;
  91. }
  92. %typemap(in) long *REFERENCE (long dvalue), long &REFERENCE(long dvalue)
  93. {
  94. SV *tempsv;
  95. if (!SvROK($input)) {
  96. SWIG_croak("expected a reference");
  97. }
  98. tempsv = SvRV($input);
  99. if (!SvIOK(tempsv)) {
  100. SWIG_croak("expected a integer reference");
  101. }
  102. dvalue = (long) SvIV(tempsv);
  103. $1 = &dvalue;
  104. }
  105. %typemap(in) unsigned int *REFERENCE (unsigned int dvalue), unsigned int &REFERENCE(unsigned int dvalue)
  106. {
  107. SV *tempsv;
  108. if (!SvROK($input)) {
  109. SWIG_croak("expected a reference");
  110. }
  111. tempsv = SvRV($input);
  112. if (!SvIOK(tempsv)) {
  113. SWIG_croak("expected a integer reference");
  114. }
  115. dvalue = (unsigned int) SvUV(tempsv);
  116. $1 = &dvalue;
  117. }
  118. %typemap(in) unsigned short *REFERENCE (unsigned short dvalue), unsigned short &REFERENCE(unsigned short dvalue)
  119. {
  120. SV *tempsv;
  121. if (!SvROK($input)) {
  122. SWIG_croak("expected a reference");
  123. }
  124. tempsv = SvRV($input);
  125. if (!SvIOK(tempsv)) {
  126. SWIG_croak("expected a integer reference");
  127. }
  128. dvalue = (unsigned short) SvUV(tempsv);
  129. $1 = &dvalue;
  130. }
  131. %typemap(in) unsigned long *REFERENCE (unsigned long dvalue), unsigned long &REFERENCE(unsigned long dvalue)
  132. {
  133. SV *tempsv;
  134. if (!SvROK($input)) {
  135. SWIG_croak("expected a reference");
  136. }
  137. tempsv = SvRV($input);
  138. if (!SvIOK(tempsv)) {
  139. SWIG_croak("expected a integer reference");
  140. }
  141. dvalue = (unsigned long) SvUV(tempsv);
  142. $1 = &dvalue;
  143. }
  144. %typemap(in) unsigned char *REFERENCE (unsigned char dvalue), unsigned char &REFERENCE(unsigned char dvalue)
  145. {
  146. SV *tempsv;
  147. if (!SvROK($input)) {
  148. SWIG_croak("expected a reference");
  149. }
  150. tempsv = SvRV($input);
  151. if (!SvIOK(tempsv)) {
  152. SWIG_croak("expected a integer reference");
  153. }
  154. dvalue = (unsigned char) SvUV(tempsv);
  155. $1 = &dvalue;
  156. }
  157. %typemap(in) signed char *REFERENCE (signed char dvalue), signed char &REFERENCE(signed char dvalue)
  158. {
  159. SV *tempsv;
  160. if (!SvROK($input)) {
  161. SWIG_croak("expected a reference");
  162. }
  163. tempsv = SvRV($input);
  164. if (!SvIOK(tempsv)) {
  165. SWIG_croak("expected a integer reference");
  166. }
  167. dvalue = (signed char) SvIV(tempsv);
  168. $1 = &dvalue;
  169. }
  170. %typemap(in) bool *REFERENCE (bool dvalue), bool &REFERENCE(bool dvalue)
  171. {
  172. SV *tempsv;
  173. if (!SvROK($input)) {
  174. SWIG_croak("expected a reference");
  175. }
  176. tempsv = SvRV($input);
  177. if (!SvIOK(tempsv)) {
  178. SWIG_croak("expected a integer reference");
  179. }
  180. dvalue = SvIV(tempsv) ? true : false;
  181. $1 = &dvalue;
  182. }
  183. %typemap(typecheck) int *REFERENCE, int &REFERENCE,
  184. short *REFERENCE, short &REFERENCE,
  185. long *REFERENCE, long &REFERENCE,
  186. signed char *REFERENCE, signed char &REFERENCE,
  187. bool *REFERENCE, bool &REFERENCE
  188. {
  189. $1 = SvROK($input) && SvIOK(SvRV($input));
  190. }
  191. %typemap(typecheck) double *REFERENCE, double &REFERENCE,
  192. float *REFERENCE, float &REFERENCE
  193. {
  194. $1 = SvROK($input);
  195. if($1) {
  196. SV *tmpsv = SvRV($input);
  197. $1 = SvNOK(tmpsv) || SvIOK(tmpsv);
  198. }
  199. }
  200. %typemap(typecheck) unsigned int *REFERENCE, unsigned int &REFERENCE,
  201. unsigned short *REFERENCE, unsigned short &REFERENCE,
  202. unsigned long *REFERENCE, unsigned long &REFERENCE,
  203. unsigned char *REFERENCE, unsigned char &REFERENCE
  204. {
  205. $1 = SvROK($input);
  206. if($1) {
  207. SV *tmpsv = SvRV($input);
  208. $1 = SvUOK(tmpsv) || SvIOK(tmpsv);
  209. }
  210. }
  211. %typemap(argout) double *REFERENCE, double &REFERENCE,
  212. float *REFERENCE, float &REFERENCE
  213. {
  214. SV *tempsv;
  215. tempsv = SvRV($arg);
  216. if (!$1) SWIG_croak("expected a reference");
  217. sv_setnv(tempsv, (double) *$1);
  218. }
  219. %typemap(argout) int *REFERENCE, int &REFERENCE,
  220. short *REFERENCE, short &REFERENCE,
  221. long *REFERENCE, long &REFERENCE,
  222. signed char *REFERENCE, signed char &REFERENCE,
  223. bool *REFERENCE, bool &REFERENCE
  224. {
  225. SV *tempsv;
  226. tempsv = SvRV($input);
  227. if (!$1) SWIG_croak("expected a reference");
  228. sv_setiv(tempsv, (IV) *$1);
  229. }
  230. %typemap(argout) unsigned int *REFERENCE, unsigned int &REFERENCE,
  231. unsigned short *REFERENCE, unsigned short &REFERENCE,
  232. unsigned long *REFERENCE, unsigned long &REFERENCE,
  233. unsigned char *REFERENCE, unsigned char &REFERENCE
  234. {
  235. SV *tempsv;
  236. tempsv = SvRV($input);
  237. if (!$1) SWIG_croak("expected a reference");
  238. sv_setuv(tempsv, (UV) *$1);
  239. }