PageRenderTime 32ms CodeModel.GetById 12ms RepoModel.GetById 1ms app.codeStats 0ms

/trunk/Lib/ruby/rubyprimtypes.swg

#
Unknown | 216 lines | 187 code | 29 blank | 0 comment | 0 complexity | 6be2e62eccc63d5ac2442427d2a88c3a MD5 | raw file
Possible License(s): LGPL-2.1, Cube, GPL-3.0, 0BSD, GPL-2.0
  1. /* -----------------------------------------------------------------------------
  2. * rubyprimtypes.swg
  3. * ----------------------------------------------------------------------------- */
  4. /* ------------------------------------------------------------
  5. * Primitive Types
  6. * ------------------------------------------------------------ */
  7. /* auxiliary ruby fail method */
  8. %fragment("SWIG_ruby_failed","header")
  9. {
  10. SWIGINTERN VALUE
  11. SWIG_ruby_failed(void)
  12. {
  13. return Qnil;
  14. }
  15. }
  16. %define %ruby_aux_method(Type, Method, Action)
  17. SWIGINTERN VALUE SWIG_AUX_##Method##(VALUE *args)
  18. {
  19. VALUE obj = args[0];
  20. VALUE type = TYPE(obj);
  21. Type *res = (Type *)(args[1]);
  22. *res = Action;
  23. return obj;
  24. }
  25. %enddef
  26. /* boolean */
  27. %fragment(SWIG_From_frag(bool),"header") {
  28. SWIGINTERNINLINE VALUE
  29. SWIG_From_dec(bool)(bool value)
  30. {
  31. return value ? Qtrue : Qfalse;
  32. }
  33. }
  34. %fragment(SWIG_AsVal_frag(bool),"header",
  35. fragment=SWIG_AsVal_frag(int)) {
  36. SWIGINTERN int
  37. SWIG_AsVal_dec(bool)(VALUE obj, bool *val)
  38. {
  39. if (obj == Qtrue) {
  40. if (val) *val = true;
  41. return SWIG_OK;
  42. } else if (obj == Qfalse) {
  43. if (val) *val = false;
  44. return SWIG_OK;
  45. } else {
  46. int res = 0;
  47. if (SWIG_AsVal(int)(obj, &res) == SWIG_OK) {
  48. if (val) *val = res ? true : false;
  49. return SWIG_OK;
  50. }
  51. }
  52. return SWIG_TypeError;
  53. }
  54. }
  55. /* long */
  56. %fragment(SWIG_From_frag(long),"header",
  57. fragment="<limits.h>") {
  58. %define_as(SWIG_From_dec(long), LONG2NUM)
  59. }
  60. %fragment(SWIG_AsVal_frag(long),"header",fragment="SWIG_ruby_failed") {
  61. %ruby_aux_method(long, NUM2LONG, type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj))
  62. SWIGINTERN int
  63. SWIG_AsVal_dec(long)(VALUE obj, long* val)
  64. {
  65. VALUE type = TYPE(obj);
  66. if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
  67. long v;
  68. VALUE a[2];
  69. a[0] = obj;
  70. a[1] = (VALUE)(&v);
  71. if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
  72. if (val) *val = v;
  73. return SWIG_OK;
  74. }
  75. }
  76. return SWIG_TypeError;
  77. }
  78. }
  79. /* unsigned long */
  80. %fragment(SWIG_From_frag(unsigned long),"header",
  81. fragment=SWIG_From_frag(long)) {
  82. SWIGINTERNINLINE VALUE
  83. SWIG_From_dec(unsigned long)(unsigned long value)
  84. {
  85. return ULONG2NUM(value);
  86. }
  87. }
  88. %fragment(SWIG_AsVal_frag(unsigned long),"header",fragment="SWIG_ruby_failed") {
  89. %ruby_aux_method(unsigned long, NUM2ULONG, type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj))
  90. SWIGINTERN int
  91. SWIG_AsVal_dec(unsigned long)(VALUE obj, unsigned long *val)
  92. {
  93. VALUE type = TYPE(obj);
  94. if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
  95. unsigned long v;
  96. VALUE a[2];
  97. a[0] = obj;
  98. a[1] = (VALUE)(&v);
  99. if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
  100. if (val) *val = v;
  101. return SWIG_OK;
  102. }
  103. }
  104. return SWIG_TypeError;
  105. }
  106. }
  107. /* long long */
  108. %fragment(SWIG_From_frag(long long),"header",
  109. fragment=SWIG_From_frag(long),
  110. fragment="<limits.h>") {
  111. SWIGINTERNINLINE VALUE
  112. SWIG_From_dec(long long)(long long value)
  113. {
  114. return LL2NUM(value);
  115. }
  116. }
  117. %fragment(SWIG_AsVal_frag(long long),"header",fragment="SWIG_ruby_failed") {
  118. %ruby_aux_method(long long, NUM2LL, type == T_FIXNUM ? NUM2LL(obj) : rb_big2ll(obj))
  119. SWIGINTERN int
  120. SWIG_AsVal_dec(long long)(VALUE obj, long long *val)
  121. {
  122. VALUE type = TYPE(obj);
  123. if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
  124. long long v;
  125. VALUE a[2];
  126. a[0] = obj;
  127. a[1] = (VALUE)(&v);
  128. if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
  129. if (val) *val = v;
  130. return SWIG_OK;
  131. }
  132. }
  133. return SWIG_TypeError;
  134. }
  135. }
  136. /* unsigned long long */
  137. %fragment(SWIG_From_frag(unsigned long long),"header",
  138. fragment=SWIG_From_frag(long long),
  139. fragment="<limits.h>") {
  140. SWIGINTERNINLINE VALUE
  141. SWIG_From_dec(unsigned long long)(unsigned long long value)
  142. {
  143. return ULL2NUM(value);
  144. }
  145. }
  146. %fragment(SWIG_AsVal_frag(unsigned long long),"header",fragment="SWIG_ruby_failed") {
  147. %ruby_aux_method(long long, NUM2ULL, type == T_FIXNUM ? NUM2ULL(obj) : rb_big2ull(obj))
  148. SWIGINTERN int
  149. SWIG_AsVal_dec(unsigned long long)(VALUE obj, unsigned long long *val)
  150. {
  151. VALUE type = TYPE(obj);
  152. if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
  153. unsigned long long v;
  154. VALUE a[2];
  155. a[0] = obj;
  156. a[1] = (VALUE)(&v);
  157. if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
  158. if (val) *val = v;
  159. return SWIG_OK;
  160. }
  161. }
  162. return SWIG_TypeError;
  163. }
  164. }
  165. /* double */
  166. %fragment(SWIG_From_frag(double),"header") {
  167. %define_as(SWIG_From_dec(double), rb_float_new)
  168. }
  169. %fragment(SWIG_AsVal_frag(double),"header",fragment="SWIG_ruby_failed") {
  170. %ruby_aux_method(double, NUM2DBL, NUM2DBL(obj))
  171. SWIGINTERN int
  172. SWIG_AsVal_dec(double)(VALUE obj, double *val)
  173. {
  174. VALUE type = TYPE(obj);
  175. if ((type == T_FLOAT) || (type == T_FIXNUM) || (type == T_BIGNUM)) {
  176. double v;
  177. VALUE a[2];
  178. a[0] = obj;
  179. a[1] = (VALUE)(&v);
  180. if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
  181. if (val) *val = v;
  182. return SWIG_OK;
  183. }
  184. }
  185. return SWIG_TypeError;
  186. }
  187. }