PageRenderTime 47ms CodeModel.GetById 23ms RepoModel.GetById 0ms app.codeStats 0ms

/ext/error.c

https://github.com/romanbsd/rb-gsl
C | 194 lines | 170 code | 14 blank | 10 comment | 2 complexity | e33a16e69464a6196b1ed15998f4f206 MD5 | raw file
Possible License(s): GPL-2.0 
    

  1. /*
    2. 

  2.   error.c
    3. 

  3.   Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library)
    4. 

  4.     (C) Copyright 2001-2006 by Yoshiki Tsunesada
    5. 

    6. 

  6.   Ruby/GSL is free software: you can redistribute it and/or modify it
    7. 

  7.   under the terms of the GNU General Public License.
    8. 

  8.   This library is distributed in the hope that it will be useful, but
    9. 

  9.   WITHOUT ANY WARRANTY.
    10. 

  10. */
    11. 

  11. #include "rb_gsl.h"
    12. 

  12. #include <gsl/gsl_errno.h>
    13. 

  13. #include "rb_gsl_array.h"
    14. 

  14. #include "rb_gsl_common.h"
    15. 

  15. #include "rb_gsl_function.h"
    16. 

  16. 

  17. static VALUE eHandler;
    18. 

  18. static VALUE cgsl_error[35];
    19. 

  19. static VALUE *pgsl_error;
    20. 

  20. 

  21. static void Init_rb_gsl_define_GSL_CONST(VALUE module);
    22. 

  22. void rb_gsl_error_handler(const char *reason, const char *file,
    23. 

  23. 			  int line, int gsl_errno);
    24. 

  24. static void rb_gsl_my_error_handler(const char *reason, const char *file,
    25. 

  25. 				    int line, int gsl_errno);
    26. 

  26. 

  27. void rb_gsl_error_handler(const char *reason, const char *file,
    28. 

  28. 			  int line, int gsl_errno)
    29. 

  29. {
    30. 

  30.   const char *emessage = gsl_strerror(gsl_errno);
    31. 

  31.   rb_raise(pgsl_error[gsl_errno], 
    32. 

  32. 	   "Ruby/GSL error code %d, %s (file %s, line %d), %s",
    33. 

  33. 	   gsl_errno, reason, file, line, emessage);
    34. 

  34. }
    35. 

  35. 

  36. static void rb_gsl_my_error_handler(const char *reason, const char *file,
    37. 

  37. 				    int line, int gsl_errno)
    38. 

  38. {
    39. 

  39.   VALUE vreason, vfile;
    40. 

  40.   VALUE vline, verrno;
    41. 

  41.   VALUE result;
    42. 

  42.   vreason = rb_str_new2(reason);
    43. 

  43.   vfile = rb_str_new2(file);
    44. 

  44.   vline = INT2FIX(line);
    45. 

  45.   verrno = INT2FIX(gsl_errno);
    46. 

  46.   result = rb_funcall(eHandler, RBGSL_ID_call, 4, vreason, vfile, vline, verrno);
    47. 

  47. }
    48. 

  48. 

  49. static VALUE rb_gsl_set_error_handler(int argc, VALUE *argv, VALUE module)
    50. 

  50. {
    51. 

  51.   if (rb_block_given_p()) {
    52. 

  52.     eHandler = RB_GSL_MAKE_PROC;
    53. 

  53.     gsl_set_error_handler(&rb_gsl_my_error_handler);
    54. 

  54.     return Qtrue;
    55. 

  55.   }
    56. 

  56.   switch (argc) {
    57. 

  57.   case 0:
    58. 

  58.     gsl_set_error_handler(&rb_gsl_error_handler);
    59. 

  59.     return Qtrue;
    60. 

  60.     break;
    61. 

  61.   case 1:
    62. 

  62.     CHECK_PROC(argv[0]);
    63. 

  63.     eHandler = argv[0];
    64. 

  64.     gsl_set_error_handler(&rb_gsl_my_error_handler);
    65. 

  65.     return Qtrue;
    66. 

  66.     break;
    67. 

  67.   default:
    68. 

  68.     rb_raise(rb_eArgError, "too many arguments (%d for 0 or 1 Proc)", argc);
    69. 

  69.     break;
    70. 

  70.   }
    71. 

  71. }
    72. 

  72. 

  73. static VALUE rb_gsl_set_default_error_handler(VALUE module)
    74. 

  74. {
    75. 

  75.   gsl_set_error_handler(&rb_gsl_error_handler);
    76. 

  76.   return Qtrue;
    77. 

  77. }
    78. 

  78. 

  79. static void rb_gsl_define_exceptions(VALUE module)
    80. 

  80. {
    81. 

  81.   VALUE mgsl_error;
    82. 

  82.   mgsl_error = rb_define_module_under(module, "ERROR");
    83. 

  83.   pgsl_error = &cgsl_error[2];
    84. 

  84.   pgsl_error[-2] = rb_define_class_under(mgsl_error, "CONTINUE", rb_cFixnum);
    85. 

  85.   pgsl_error[-1] = rb_define_class_under(mgsl_error, "FAILURE", rb_eRuntimeError);
    86. 

  86.   pgsl_error[0] = rb_define_class_under(mgsl_error, "SUCCESS", rb_cFixnum);
    87. 

  87.   pgsl_error[1] = rb_define_class_under(mgsl_error, "EDOM", rb_eRangeError);
    88. 

  88.   pgsl_error[2] = rb_define_class_under(mgsl_error, "ERANGE", rb_eRangeError);
    89. 

  89.   pgsl_error[3] = rb_define_class_under(mgsl_error, "EFAULT", rb_eRuntimeError);
    90. 

  90.   pgsl_error[4] = rb_define_class_under(mgsl_error, "EINVAL", rb_eIndexError);
    91. 

  91.   pgsl_error[5] = rb_define_class_under(mgsl_error, "EFAILED", rb_eRuntimeError);
    92. 

  92.   pgsl_error[6] = rb_define_class_under(mgsl_error, "EFACTOR", rb_eRuntimeError);
    93. 

  93.   pgsl_error[7] = rb_define_class_under(mgsl_error, "ESANITY", rb_eRuntimeError);
    94. 

  94.   pgsl_error[8] = rb_define_class_under(mgsl_error, "ENOMEM", rb_eNoMemError);
    95. 

  95.   pgsl_error[9] = rb_define_class_under(mgsl_error, "EBADFUNC", rb_eRuntimeError);
    96. 

  96.   pgsl_error[10] = rb_define_class_under(mgsl_error, "ERUNAWAY", rb_eRuntimeError);
    97. 

  97.   pgsl_error[11] = rb_define_class_under(mgsl_error, "EMAXITER", rb_eRuntimeError);
    98. 

  98.   pgsl_error[12] = rb_define_class_under(mgsl_error, "EZERODIV", rb_eZeroDivError);
    99. 

  99.   pgsl_error[13] = rb_define_class_under(mgsl_error, "EBADTOL", rb_eRuntimeError);
    100. 

  100.   pgsl_error[14] = rb_define_class_under(mgsl_error, "ETOL", rb_eRuntimeError);
    101. 

  101.   pgsl_error[15] = rb_define_class_under(mgsl_error, "EUNDRFLW", rb_eRangeError);
    102. 

  102.   pgsl_error[16] = rb_define_class_under(mgsl_error, "EOVRFLW", rb_eRangeError);
    103. 

  103.   pgsl_error[17] = rb_define_class_under(mgsl_error, "ELOSS", rb_eRuntimeError);
    104. 

  104.   pgsl_error[18] = rb_define_class_under(mgsl_error, "EROUND", rb_eRuntimeError);
    105. 

  105.   pgsl_error[19] = rb_define_class_under(mgsl_error, "EBADLEN", rb_eIndexError);
    106. 

  106.   pgsl_error[20] = rb_define_class_under(mgsl_error, "ENOTSQR", rb_eRuntimeError);
    107. 

  107.   pgsl_error[21] = rb_define_class_under(mgsl_error, "ESING", rb_eRuntimeError);
    108. 

  108.   pgsl_error[22] = rb_define_class_under(mgsl_error, "EDIVERGE", rb_eRuntimeError);
    109. 

  109.   pgsl_error[23] = rb_define_class_under(mgsl_error, "EUNSUP", rb_eRuntimeError);
    110. 

  110.   pgsl_error[24] = rb_define_class_under(mgsl_error, "EUNIMPL", rb_eNotImpError);
    111. 

  111.   pgsl_error[25] = rb_define_class_under(mgsl_error, "ECACHE", rb_eRuntimeError);
    112. 

  112.   pgsl_error[26] = rb_define_class_under(mgsl_error, "ETABLE", rb_eRuntimeError);
    113. 

  113.   pgsl_error[27] = rb_define_class_under(mgsl_error, "ENOPROG", rb_eRuntimeError);
    114. 

  114.   pgsl_error[28] = rb_define_class_under(mgsl_error, "ENOPROGJ", rb_eRuntimeError);
    115. 

  115.   pgsl_error[29] = rb_define_class_under(mgsl_error, "ETOLF", rb_eRuntimeError);
    116. 

  116.   pgsl_error[30] = rb_define_class_under(mgsl_error, "ETOLX", rb_eRuntimeError);
    117. 

  117.   pgsl_error[31] = rb_define_class_under(mgsl_error, "ETOLG", rb_eRuntimeError);
    118. 

  118.   pgsl_error[32] = rb_define_class_under(mgsl_error, "EOF", rb_eEOFError);
    119. 

  119. }
    120. 

  120. 

  121. static void Init_rb_gsl_define_GSL_CONST(VALUE module)
    122. 

  122. {
    123. 

  123.   rb_define_const(module, "SUCCESS", INT2FIX(GSL_SUCCESS));
    124. 

  124.   rb_define_const(module, "FAILURE", INT2FIX(GSL_FAILURE));
    125. 

  125.   rb_define_const(module, "CONTINUE", INT2FIX(GSL_CONTINUE));
    126. 

  126.   rb_define_const(module, "EDOM", INT2FIX(GSL_EDOM));
    127. 

  127.   rb_define_const(module, "ERANGE", INT2FIX(GSL_ERANGE));
    128. 

  128.   rb_define_const(module, "EFAULT", INT2FIX(GSL_EFAULT));
    129. 

  129.   rb_define_const(module, "EINVAL", INT2FIX(GSL_EINVAL));
    130. 

  130.   rb_define_const(module, "EFAILED", INT2FIX(GSL_EFAILED));
    131. 

  131.   rb_define_const(module, "EFACTOR", INT2FIX(GSL_EFACTOR));
    132. 

  132.   rb_define_const(module, "ESANITY", INT2FIX(GSL_ESANITY));
    133. 

  133.   rb_define_const(module, "ENOMEM", INT2FIX(GSL_ENOMEM));
    134. 

  134.   rb_define_const(module, "EBADFUNC", INT2FIX(GSL_EBADFUNC));
    135. 

  135.   rb_define_const(module, "ERUNAWAY", INT2FIX(GSL_ERUNAWAY));
    136. 

  136.   rb_define_const(module, "EMAXITER", INT2FIX(GSL_EMAXITER));
    137. 

  137.   rb_define_const(module, "EZERODIV", INT2FIX(GSL_EZERODIV));
    138. 

  138.   rb_define_const(module, "EBADTOL", INT2FIX(GSL_EBADTOL));
    139. 

  139.   rb_define_const(module, "ETOL", INT2FIX(GSL_ETOL));
    140. 

  140.   rb_define_const(module, "EUNDRFLW", INT2FIX(GSL_EUNDRFLW));
    141. 

  141.   rb_define_const(module, "EOVRFLW", INT2FIX(GSL_EOVRFLW));
    142. 

  142.   rb_define_const(module, "ELOSS", INT2FIX(GSL_ELOSS));
    143. 

  143.   rb_define_const(module, "EROUND", INT2FIX(GSL_EROUND));
    144. 

  144.   rb_define_const(module, "EBADLEN", INT2FIX(GSL_EBADLEN));
    145. 

  145.   rb_define_const(module, "ENOTSQR", INT2FIX(GSL_ENOTSQR));
    146. 

  146.   rb_define_const(module, "ESING", INT2FIX(GSL_ESING));
    147. 

  147.   rb_define_const(module, "EDIVERGE", INT2FIX(GSL_EDIVERGE));
    148. 

  148.   rb_define_const(module, "EUNSUP", INT2FIX(GSL_EUNSUP));
    149. 

  149.   rb_define_const(module, "EUNIMPL", INT2FIX(GSL_EUNIMPL));
    150. 

  150.   rb_define_const(module, "ECACHE", INT2FIX(GSL_ECACHE));
    151. 

  151.   rb_define_const(module, "ETABLE", INT2FIX(GSL_ETABLE));
    152. 

  152.   rb_define_const(module, "ENOPROG", INT2FIX(GSL_ENOPROG));
    153. 

  153.   rb_define_const(module, "ENOPROGJ", INT2FIX(GSL_ENOPROGJ));
    154. 

  154.   rb_define_const(module, "ETOLF", INT2FIX(GSL_ETOLF));
    155. 

  155.   rb_define_const(module, "ETOLX", INT2FIX(GSL_ETOLX));
    156. 

  156.   rb_define_const(module, "ETOLG", INT2FIX(GSL_ETOLG));
    157. 

  157.   rb_define_const(module, "EOF", INT2FIX(GSL_EOF));
    158. 

  158. }
    159. 

  159. 

  160. static VALUE rb_gsl_set_error_handler_off(VALUE module)
    161. 

  161. {
    162. 

  162.   gsl_set_error_handler_off();
    163. 

  163.   return Qtrue;
    164. 

  164. }
    165. 

  165. 

  166. static void define_module_functions(VALUE module);
    167. 

  167. static VALUE rb_gsl_strerror(VALUE obj, VALUE errn);
    168. 

  168. static void define_module_functions(VALUE module)
    169. 

  169. {
    170. 

  170.   rb_define_module_function(module, "set_error_handler_off", 
    171. 

  171. 			    rb_gsl_set_error_handler_off, 0);
    172. 

  172.   rb_define_module_function(module, "strerror", 
    173. 

  173. 			    rb_gsl_strerror, 1);
    174. 

  174.   rb_define_module_function(module, "set_error_handler",
    175. 

  175. 			    rb_gsl_set_error_handler, -1);
    176. 

  176.   rb_define_module_function(module, "set_default_error_handler",
    177. 

  177. 			    rb_gsl_set_default_error_handler, 0);
    178. 

  178. }
    179. 

  179. 

  180. static VALUE rb_gsl_strerror(VALUE obj, VALUE errn)
    181. 

  181. {
    182. 

  182.   int gsl_errno = FIX2INT(errn);
    183. 

  183.   return rb_str_new2(gsl_strerror(gsl_errno));
    184. 

  184. }
    185. 

  185. 

  186. void Init_gsl_error(VALUE module)
    187. 

  187. {
    188. 

  188.   Init_rb_gsl_define_GSL_CONST(module);
    189. 

  189. 

  190.   gsl_set_error_handler(&rb_gsl_error_handler);
    191. 

  191. 

  192.   define_module_functions(module);
    193. 

  193.   rb_gsl_define_exceptions(module);
    194. 

  194. }
    195. 

  195.