summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[ruby/json] Use RB_TYPE_P
[ruby.git] / error.c
blobd3aeec54d8b97c73b51847f6be265fdcbb3bf0ee
1 /**********************************************************************
2
3 error.c -
4
5 $Author$
6 created at: Mon Aug 9 16:11:34 JST 1993
7
8 Copyright (C) 1993-2007 Yukihiro Matsumoto
9
10 **********************************************************************/
11
12 #include "ruby/internal/config.h"
13
14 #include <errno.h>
15 #include <stdarg.h>
16 #include <stdio.h>
17
18 #ifdef HAVE_STDLIB_H
19 # include <stdlib.h>
20 #endif
21
22 #ifdef HAVE_UNISTD_H
23 # include <unistd.h>
24 #endif
25
26 #ifdef HAVE_SYS_WAIT_H
27 # include <sys/wait.h>
28 #endif
29
30 #if defined __APPLE__
31 # include <AvailabilityMacros.h>
32 #endif
33
34 #include "internal.h"
35 #include "internal/class.h"
36 #include "internal/error.h"
37 #include "internal/eval.h"
38 #include "internal/hash.h"
39 #include "internal/io.h"
40 #include "internal/load.h"
41 #include "internal/object.h"
42 #include "internal/process.h"
43 #include "internal/string.h"
44 #include "internal/symbol.h"
45 #include "internal/thread.h"
46 #include "internal/variable.h"
47 #include "ruby/encoding.h"
48 #include "ruby/st.h"
49 #include "ruby/util.h"
50 #include "ruby_assert.h"
51 #include "vm_core.h"
52 #include "yjit.h"
53
54 #include "builtin.h"
55
56 /*!
57 * \addtogroup exception
58 * \{
59 */
60
61 #ifndef EXIT_SUCCESS
62 #define EXIT_SUCCESS 0
63 #endif
64
65 #ifndef WIFEXITED
66 #define WIFEXITED(status) 1
67 #endif
68
69 #ifndef WEXITSTATUS
70 #define WEXITSTATUS(status) (status)
71 #endif
72
73 VALUE rb_iseqw_local_variables(VALUE iseqval);
74 VALUE rb_iseqw_new(const rb_iseq_t *);
75 int rb_str_end_with_asciichar(VALUE str, int c);
76
77 long rb_backtrace_length_limit = -1;
78 VALUE rb_eEAGAIN;
79 VALUE rb_eEWOULDBLOCK;
80 VALUE rb_eEINPROGRESS;
81 static VALUE rb_mWarning;
82 static VALUE rb_cWarningBuffer;
83
84 static ID id_warn;
85 static ID id_category;
86 static ID id_deprecated;
87 static ID id_experimental;
88 static ID id_performance;
89 static ID id_strict_unused_block;
90 static VALUE sym_category;
91 static VALUE sym_highlight;
92 static struct {
93 st_table *id2enum, *enum2id;
94 } warning_categories;
95
96 extern const char *rb_dynamic_description;
97
98 static const char *
99 rb_strerrno(int err)
100 {
101 #define defined_error(name, num) if (err == (num)) return (name);
102 #define undefined_error(name)
103 #include "known_errors.inc"
104 #undef defined_error
105 #undef undefined_error
106 return NULL;
107 }
108
109 static int
110 err_position_0(char *buf, long len, const char *file, int line)
111 {
112 if (!file) {
113 return 0;
114 }
115 else if (line == 0) {
116 return snprintf(buf, len, "%s: ", file);
117 }
118 else {
119 return snprintf(buf, len, "%s:%d: ", file, line);
120 }
121 }
122
123 RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 5, 0)
124 static VALUE
125 err_vcatf(VALUE str, const char *pre, const char *file, int line,
126 const char *fmt, va_list args)
127 {
128 if (file) {
129 rb_str_cat2(str, file);
130 if (line) rb_str_catf(str, ":%d", line);
131 rb_str_cat2(str, ": ");
132 }
133 if (pre) rb_str_cat2(str, pre);
134 rb_str_vcatf(str, fmt, args);
135 return str;
136 }
137
138 static VALUE syntax_error_with_path(VALUE, VALUE, VALUE*, rb_encoding*);
139
140 VALUE
141 rb_syntax_error_append(VALUE exc, VALUE file, int line, int column,
142 rb_encoding *enc, const char *fmt, va_list args)
143 {
144 const char *fn = NIL_P(file) ? NULL : RSTRING_PTR(file);
145 if (!exc) {
146 VALUE mesg = rb_enc_str_new(0, 0, enc);
147 err_vcatf(mesg, NULL, fn, line, fmt, args);
148 rb_str_cat2(mesg, "\n");
149 rb_write_error_str(mesg);
150 }
151 else {
152 VALUE mesg;
153 exc = syntax_error_with_path(exc, file, &mesg, enc);
154 err_vcatf(mesg, NULL, fn, line, fmt, args);
155 }
156
157 return exc;
158 }
159
160 static unsigned int warning_disabled_categories = (
161 (1U << RB_WARN_CATEGORY_DEPRECATED) |
162 ~RB_WARN_CATEGORY_DEFAULT_BITS);
163
164 static unsigned int
165 rb_warning_category_mask(VALUE category)
166 {
167 return 1U << rb_warning_category_from_name(category);
168 }
169
170 rb_warning_category_t
171 rb_warning_category_from_name(VALUE category)
172 {
173 st_data_t cat_value;
174 ID cat_id;
175 Check_Type(category, T_SYMBOL);
176 if (!(cat_id = rb_check_id(&category)) ||
177 !st_lookup(warning_categories.id2enum, cat_id, &cat_value)) {
178 rb_raise(rb_eArgError, "unknown category: %"PRIsVALUE, category);
179 }
180 return (rb_warning_category_t)cat_value;
181 }
182
183 static VALUE
184 rb_warning_category_to_name(rb_warning_category_t category)
185 {
186 st_data_t id;
187 if (!st_lookup(warning_categories.enum2id, category, &id)) {
188 rb_raise(rb_eArgError, "invalid category: %d", (int)category);
189 }
190 return id ? ID2SYM(id) : Qnil;
191 }
192
193 void
194 rb_warning_category_update(unsigned int mask, unsigned int bits)
195 {
196 warning_disabled_categories &= ~mask;
197 warning_disabled_categories |= mask & ~bits;
198 }
199
200 bool
201 rb_warning_category_enabled_p(rb_warning_category_t category)
202 {
203 return !(warning_disabled_categories & (1U << category));
204 }
205
206 /*
207 * call-seq:
208 * Warning[category] -> true or false
209 *
210 * Returns the flag to show the warning messages for +category+.
211 * Supported categories are:
212 *
213 * +:deprecated+ ::
214 * deprecation warnings
215 * * assignment of non-nil value to <code>$,</code> and <code>$;</code>
216 * * keyword arguments
217 * etc.
218 *
219 * +:experimental+ ::
220 * experimental features
221 *
222 * +:performance+ ::
223 * performance hints
224 * * Shape variation limit
225 */
226
227 static VALUE
228 rb_warning_s_aref(VALUE mod, VALUE category)
229 {
230 rb_warning_category_t cat = rb_warning_category_from_name(category);
231 return RBOOL(rb_warning_category_enabled_p(cat));
232 }
233
234 /*
235 * call-seq:
236 * Warning[category] = flag -> flag
237 *
238 * Sets the warning flags for +category+.
239 * See Warning.[] for the categories.
240 */
241
242 static VALUE
243 rb_warning_s_aset(VALUE mod, VALUE category, VALUE flag)
244 {
245 unsigned int mask = rb_warning_category_mask(category);
246 unsigned int disabled = warning_disabled_categories;
247 if (!RTEST(flag))
248 disabled |= mask;
249 else
250 disabled &= ~mask;
251 warning_disabled_categories = disabled;
252 return flag;
253 }
254
255 /*
256 * call-seq:
257 * categories -> array
258 *
259 * Returns a list of the supported category symbols.
260 */
261
262 static VALUE
263 rb_warning_s_categories(VALUE mod)
264 {
265 st_index_t num = warning_categories.id2enum->num_entries;
266 ID *ids = ALLOCA_N(ID, num);
267 num = st_keys(warning_categories.id2enum, ids, num);
268 VALUE ary = rb_ary_new_capa(num);
269 for (st_index_t i = 0; i < num; ++i) {
270 rb_ary_push(ary, ID2SYM(ids[i]));
271 }
272 return rb_ary_freeze(ary);
273 }
274
275 /*
276 * call-seq:
277 * warn(msg, category: nil) -> nil
278 *
279 * Writes warning message +msg+ to $stderr. This method is called by
280 * Ruby for all emitted warnings. A +category+ may be included with
281 * the warning.
282 *
283 * See the documentation of the Warning module for how to customize this.
284 */
285
286 static VALUE
287 rb_warning_s_warn(int argc, VALUE *argv, VALUE mod)
288 {
289 VALUE str;
290 VALUE opt;
291 VALUE category = Qnil;
292
293 rb_scan_args(argc, argv, "1:", &str, &opt);
294 if (!NIL_P(opt)) rb_get_kwargs(opt, &id_category, 0, 1, &category);
295
296 Check_Type(str, T_STRING);
297 rb_must_asciicompat(str);
298 if (!NIL_P(category)) {
299 rb_warning_category_t cat = rb_warning_category_from_name(category);
300 if (!rb_warning_category_enabled_p(cat)) return Qnil;
301 }
302 rb_write_error_str(str);
303 return Qnil;
304 }
305
306 /*
307 * Document-module: Warning
308 *
309 * The Warning module contains a single method named #warn, and the
310 * module extends itself, making Warning.warn available.
311 * Warning.warn is called for all warnings issued by Ruby.
312 * By default, warnings are printed to $stderr.
313 *
314 * Changing the behavior of Warning.warn is useful to customize how warnings are
315 * handled by Ruby, for instance by filtering some warnings, and/or outputting
316 * warnings somewhere other than <tt>$stderr</tt>.
317 *
318 * If you want to change the behavior of Warning.warn you should use
319 * <tt>Warning.extend(MyNewModuleWithWarnMethod)</tt> and you can use +super+
320 * to get the default behavior of printing the warning to <tt>$stderr</tt>.
321 *
322 * Example:
323 * module MyWarningFilter
324 * def warn(message, category: nil, **kwargs)
325 * if /some warning I want to ignore/.match?(message)
326 * # ignore
327 * else
328 * super
329 * end
330 * end
331 * end
332 * Warning.extend MyWarningFilter
333 *
334 * You should never redefine Warning#warn (the instance method), as that will
335 * then no longer provide a way to use the default behavior.
336 *
337 * The warning[https://rubygems.org/gems/warning] gem provides convenient ways to customize Warning.warn.
338 */
339
340 static VALUE
341 rb_warning_warn(VALUE mod, VALUE str)
342 {
343 return rb_funcallv(mod, id_warn, 1, &str);
344 }
345
346
347 static int
348 rb_warning_warn_arity(void)
349 {
350 const rb_method_entry_t *me = rb_method_entry(rb_singleton_class(rb_mWarning), id_warn);
351 return me ? rb_method_entry_arity(me) : 1;
352 }
353
354 static VALUE
355 rb_warn_category(VALUE str, VALUE category)
356 {
357 if (RUBY_DEBUG && !NIL_P(category)) {
358 rb_warning_category_from_name(category);
359 }
360
361 if (rb_warning_warn_arity() == 1) {
362 return rb_warning_warn(rb_mWarning, str);
363 }
364 else {
365 VALUE args[2];
366 args[0] = str;
367 args[1] = rb_hash_new();
368 rb_hash_aset(args[1], sym_category, category);
369 return rb_funcallv_kw(rb_mWarning, id_warn, 2, args, RB_PASS_KEYWORDS);
370 }
371 }
372
373 static void
374 rb_write_warning_str(VALUE str)
375 {
376 rb_warning_warn(rb_mWarning, str);
377 }
378
379 RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 4, 0)
380 static VALUE
381 warn_vsprintf(rb_encoding *enc, const char *file, int line, const char *fmt, va_list args)
382 {
383 VALUE str = rb_enc_str_new(0, 0, enc);
384
385 err_vcatf(str, "warning: ", file, line, fmt, args);
386 return rb_str_cat2(str, "\n");
387 }
388
389 #define with_warn_vsprintf(enc, file, line, fmt) \
390 VALUE str; \
391 va_list args; \
392 va_start(args, fmt); \
393 str = warn_vsprintf(enc, file, line, fmt, args); \
394 va_end(args);
395
396 void
397 rb_compile_warn(const char *file, int line, const char *fmt, ...)
398 {
399 if (!NIL_P(ruby_verbose)) {
400 with_warn_vsprintf(NULL, file, line, fmt) {
401 rb_write_warning_str(str);
402 }
403 }
404 }
405
406 void
407 rb_enc_compile_warn(rb_encoding *enc, const char *file, int line, const char *fmt, ...)
408 {
409 if (!NIL_P(ruby_verbose)) {
410 with_warn_vsprintf(enc, file, line, fmt) {
411 rb_write_warning_str(str);
412 }
413 }
414 }
415
416 /* rb_compile_warning() reports only in verbose mode */
417 void
418 rb_compile_warning(const char *file, int line, const char *fmt, ...)
419 {
420 if (RTEST(ruby_verbose)) {
421 with_warn_vsprintf(NULL, file, line, fmt) {
422 rb_write_warning_str(str);
423 }
424 }
425 }
426
427 /* rb_enc_compile_warning() reports only in verbose mode */
428 void
429 rb_enc_compile_warning(rb_encoding *enc, const char *file, int line, const char *fmt, ...)
430 {
431 if (RTEST(ruby_verbose)) {
432 with_warn_vsprintf(enc, file, line, fmt) {
433 rb_write_warning_str(str);
434 }
435 }
436 }
437
438 void
439 rb_category_compile_warn(rb_warning_category_t category, const char *file, int line, const char *fmt, ...)
440 {
441 if (!NIL_P(ruby_verbose)) {
442 with_warn_vsprintf(NULL, file, line, fmt) {
443 rb_warn_category(str, rb_warning_category_to_name(category));
444 }
445 }
446 }
447
448 RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 2, 0)
449 static VALUE
450 warning_string(rb_encoding *enc, const char *fmt, va_list args)
451 {
452 int line;
453 const char *file = rb_source_location_cstr(&line);
454 return warn_vsprintf(enc, file, line, fmt, args);
455 }
456
457 #define with_warning_string(mesg, enc, fmt) \
458 with_warning_string_from(mesg, enc, fmt, fmt)
459 #define with_warning_string_from(mesg, enc, fmt, last_arg) \
460 VALUE mesg; \
461 va_list args; va_start(args, last_arg); \
462 mesg = warning_string(enc, fmt, args); \
463 va_end(args);
464
465 void
466 rb_warn(const char *fmt, ...)
467 {
468 if (!NIL_P(ruby_verbose)) {
469 with_warning_string(mesg, 0, fmt) {
470 rb_write_warning_str(mesg);
471 }
472 }
473 }
474
475 void
476 rb_category_warn(rb_warning_category_t category, const char *fmt, ...)
477 {
478 if (!NIL_P(ruby_verbose) && rb_warning_category_enabled_p(category)) {
479 with_warning_string(mesg, 0, fmt) {
480 rb_warn_category(mesg, rb_warning_category_to_name(category));
481 }
482 }
483 }
484
485 void
486 rb_enc_warn(rb_encoding *enc, const char *fmt, ...)
487 {
488 if (!NIL_P(ruby_verbose)) {
489 with_warning_string(mesg, enc, fmt) {
490 rb_write_warning_str(mesg);
491 }
492 }
493 }
494
495 /* rb_warning() reports only in verbose mode */
496 void
497 rb_warning(const char *fmt, ...)
498 {
499 if (RTEST(ruby_verbose)) {
500 with_warning_string(mesg, 0, fmt) {
501 rb_write_warning_str(mesg);
502 }
503 }
504 }
505
506 /* rb_category_warning() reports only in verbose mode */
507 void
508 rb_category_warning(rb_warning_category_t category, const char *fmt, ...)
509 {
510 if (RTEST(ruby_verbose) && rb_warning_category_enabled_p(category)) {
511 with_warning_string(mesg, 0, fmt) {
512 rb_warn_category(mesg, rb_warning_category_to_name(category));
513 }
514 }
515 }
516
517 VALUE
518 rb_warning_string(const char *fmt, ...)
519 {
520 with_warning_string(mesg, 0, fmt) {
521 }
522 return mesg;
523 }
524
525 #if 0
526 void
527 rb_enc_warning(rb_encoding *enc, const char *fmt, ...)
528 {
529 if (RTEST(ruby_verbose)) {
530 with_warning_string(mesg, enc, fmt) {
531 rb_write_warning_str(mesg);
532 }
533 }
534 }
535 #endif
536
537 static bool
538 deprecation_warning_enabled(void)
539 {
540 if (NIL_P(ruby_verbose)) return false;
541 if (!rb_warning_category_enabled_p(RB_WARN_CATEGORY_DEPRECATED)) return false;
542 return true;
543 }
544
545 static void
546 warn_deprecated(VALUE mesg, const char *removal, const char *suggest)
547 {
548 rb_str_set_len(mesg, RSTRING_LEN(mesg) - 1);
549 rb_str_cat_cstr(mesg, " is deprecated");
550 if (removal) {
551 rb_str_catf(mesg, " and will be removed in Ruby %s", removal);
552 }
553 if (suggest) rb_str_catf(mesg, "; use %s instead", suggest);
554 rb_str_cat_cstr(mesg, "\n");
555 rb_warn_category(mesg, ID2SYM(id_deprecated));
556 }
557
558 void
559 rb_warn_deprecated(const char *fmt, const char *suggest, ...)
560 {
561 if (!deprecation_warning_enabled()) return;
562
563 with_warning_string_from(mesg, 0, fmt, suggest) {
564 warn_deprecated(mesg, NULL, suggest);
565 }
566 }
567
568 void
569 rb_warn_deprecated_to_remove(const char *removal, const char *fmt, const char *suggest, ...)
570 {
571 if (!deprecation_warning_enabled()) return;
572
573 with_warning_string_from(mesg, 0, fmt, suggest) {
574 warn_deprecated(mesg, removal, suggest);
575 }
576 }
577
578 void
579 rb_warn_reserved_name(const char *coming, const char *fmt, ...)
580 {
581 if (!deprecation_warning_enabled()) return;
582
583 with_warning_string_from(mesg, 0, fmt, fmt) {
584 rb_str_set_len(mesg, RSTRING_LEN(mesg) - 1);
585 rb_str_catf(mesg, " is reserved for Ruby %s\n", coming);
586 rb_warn_category(mesg, ID2SYM(id_deprecated));
587 }
588 }
589
590 static inline int
591 end_with_asciichar(VALUE str, int c)
592 {
593 return RB_TYPE_P(str, T_STRING) &&
594 rb_str_end_with_asciichar(str, c);
595 }
596
597 /* :nodoc: */
598 static VALUE
599 warning_write(int argc, VALUE *argv, VALUE buf)
600 {
601 while (argc-- > 0) {
602 rb_str_append(buf, *argv++);
603 }
604 return buf;
605 }
606
607 VALUE rb_ec_backtrace_location_ary(const rb_execution_context_t *ec, long lev, long n, bool skip_internal);
608
609 static VALUE
610 rb_warn_m(rb_execution_context_t *ec, VALUE exc, VALUE msgs, VALUE uplevel, VALUE category)
611 {
612 VALUE location = Qnil;
613 int argc = RARRAY_LENINT(msgs);
614 const VALUE *argv = RARRAY_CONST_PTR(msgs);
615
616 if (!NIL_P(ruby_verbose) && argc > 0) {
617 VALUE str = argv[0];
618 if (!NIL_P(uplevel)) {
619 long lev = NUM2LONG(uplevel);
620 if (lev < 0) {
621 rb_raise(rb_eArgError, "negative level (%ld)", lev);
622 }
623 location = rb_ec_backtrace_location_ary(ec, lev + 1, 1, TRUE);
624 if (!NIL_P(location)) {
625 location = rb_ary_entry(location, 0);
626 }
627 }
628 if (argc > 1 || !NIL_P(uplevel) || !end_with_asciichar(str, '\n')) {
629 VALUE path;
630 if (NIL_P(uplevel)) {
631 str = rb_str_tmp_new(0);
632 }
633 else if (NIL_P(location) ||
634 NIL_P(path = rb_funcall(location, rb_intern("path"), 0))) {
635 str = rb_str_new_cstr("warning: ");
636 }
637 else {
638 str = rb_sprintf("%s:%ld: warning: ",
639 rb_string_value_ptr(&path),
640 NUM2LONG(rb_funcall(location, rb_intern("lineno"), 0)));
641 }
642 RBASIC_SET_CLASS(str, rb_cWarningBuffer);
643 rb_io_puts(argc, argv, str);
644 RBASIC_SET_CLASS(str, rb_cString);
645 }
646
647 if (!NIL_P(category)) {
648 category = rb_to_symbol_type(category);
649 rb_warning_category_from_name(category);
650 }
651
652 if (exc == rb_mWarning) {
653 rb_must_asciicompat(str);
654 rb_write_error_str(str);
655 }
656 else {
657 rb_warn_category(str, category);
658 }
659 }
660 return Qnil;
661 }
662
663 #define MAX_BUG_REPORTERS 0x100
664
665 static struct bug_reporters {
666 void (*func)(FILE *out, void *data);
667 void *data;
668 } bug_reporters[MAX_BUG_REPORTERS];
669
670 static int bug_reporters_size;
671
672 int
673 rb_bug_reporter_add(void (*func)(FILE *, void *), void *data)
674 {
675 struct bug_reporters *reporter;
676 if (bug_reporters_size >= MAX_BUG_REPORTERS) {
677 return 0; /* failed to register */
678 }
679 reporter = &bug_reporters[bug_reporters_size++];
680 reporter->func = func;
681 reporter->data = data;
682
683 return 1;
684 }
685
686 /* returns true if x can not be used as file name */
687 static bool
688 path_sep_p(char x)
689 {
690 #if defined __CYGWIN__ || defined DOSISH
691 # define PATH_SEP_ENCODING 1
692 // Assume that "/" is only the first byte in any encoding.
693 if (x == ':') return true; // drive letter or ADS
694 if (x == '\\') return true;
695 #endif
696 return x == '/';
697 }
698
699 struct path_string {
700 const char *ptr;
701 size_t len;
702 };
703
704 static const char PATHSEP_REPLACE = '!';
705
706 static char *
707 append_pathname(char *p, const char *pe, VALUE str)
708 {
709 #ifdef PATH_SEP_ENCODING
710 rb_encoding *enc = rb_enc_get(str);
711 #endif
712 const char *s = RSTRING_PTR(str);
713 const char *const se = s + RSTRING_LEN(str);
714 char c;
715
716 --pe; // for terminator
717
718 while (p < pe && s < se && (c = *s) != '\0') {
719 if (c == '.') {
720 if (s == se || !*s) break; // chomp "." basename
721 if (path_sep_p(s[1])) goto skipsep; // skip "./"
722 }
723 else if (path_sep_p(c)) {
724 // squeeze successive separators
725 *p++ = PATHSEP_REPLACE;
726 skipsep:
727 while (++s < se && path_sep_p(*s));
728 continue;
729 }
730 const char *const ss = s;
731 while (p < pe && s < se && *s && !path_sep_p(*s)) {
732 #ifdef PATH_SEP_ENCODING
733 int n = rb_enc_mbclen(s, se, enc);
734 #else
735 const int n = 1;
736 #endif
737 p += n;
738 s += n;
739 }
740 if (s > ss) memcpy(p - (s - ss), ss, s - ss);
741 }
742
743 return p;
744 }
745
746 static char *
747 append_basename(char *p, const char *pe, struct path_string *path, VALUE str)
748 {
749 if (!path->ptr) {
750 #ifdef PATH_SEP_ENCODING
751 rb_encoding *enc = rb_enc_get(str);
752 #endif
753 const char *const b = RSTRING_PTR(str), *const e = RSTRING_END(str), *p = e;
754
755 while (p > b) {
756 if (path_sep_p(p[-1])) {
757 #ifdef PATH_SEP_ENCODING
758 const char *t = rb_enc_prev_char(b, p, e, enc);
759 if (t == p-1) break;
760 p = t;
761 #else
762 break;
763 #endif
764 }
765 else {
766 --p;
767 }
768 }
769
770 path->ptr = p;
771 path->len = e - p;
772 }
773 size_t n = path->len;
774 if (p + n > pe) n = pe - p;
775 memcpy(p, path->ptr, n);
776 return p + n;
777 }
778
779 static void
780 finish_report(FILE *out, rb_pid_t pid)
781 {
782 if (out != stdout && out != stderr) fclose(out);
783 #ifdef HAVE_WORKING_FORK
784 if (pid > 0) waitpid(pid, NULL, 0);
785 #endif
786 }
787
788 struct report_expansion {
789 struct path_string exe, script;
790 rb_pid_t pid;
791 time_t time;
792 };
793
794 /*
795 * Open a bug report file to write. The `RUBY_CRASH_REPORT`
796 * environment variable can be set to define a template that is used
797 * to name bug report files. The template can contain % specifiers
798 * which are substituted by the following values when a bug report
799 * file is created:
800 *
801 * %% A single % character.
802 * %e The base name of the executable filename.
803 * %E Pathname of executable, with slashes ('/') replaced by
804 * exclamation marks ('!').
805 * %f Similar to %e with the main script filename.
806 * %F Similar to %E with the main script filename.
807 * %p PID of dumped process in decimal.
808 * %t Time of dump, expressed as seconds since the Epoch,
809 * 1970-01-01 00:00:00 +0000 (UTC).
810 * %NNN Octal char code, upto 3 digits.
811 */
812 static char *
813 expand_report_argument(const char **input_template, struct report_expansion *values,
814 char *buf, size_t size, bool word)
815 {
816 char *p = buf;
817 char *end = buf + size;
818 const char *template = *input_template;
819 bool store = true;
820
821 if (p >= end-1 || !*template) return NULL;
822 do {
823 char c = *template++;
824 if (word && ISSPACE(c)) break;
825 if (!store) continue;
826 if (c == '%') {
827 size_t n;
828 switch (c = *template++) {
829 case 'e':
830 p = append_basename(p, end, &values->exe, rb_argv0);
831 continue;
832 case 'E':
833 p = append_pathname(p, end, rb_argv0);
834 continue;
835 case 'f':
836 p = append_basename(p, end, &values->script, GET_VM()->orig_progname);
837 continue;
838 case 'F':
839 p = append_pathname(p, end, GET_VM()->orig_progname);
840 continue;
841 case 'p':
842 if (!values->pid) values->pid = getpid();
843 snprintf(p, end-p, "%" PRI_PIDT_PREFIX "d", values->pid);
844 p += strlen(p);
845 continue;
846 case 't':
847 if (!values->time) values->time = time(NULL);
848 snprintf(p, end-p, "%" PRI_TIMET_PREFIX "d", values->time);
849 p += strlen(p);
850 continue;
851 default:
852 if (c >= '0' && c <= '7') {
853 c = (unsigned char)ruby_scan_oct(template-1, 3, &n);
854 template += n - 1;
855 if (!c) store = false;
856 }
857 break;
858 }
859 }
860 if (p < end-1) *p++ = c;
861 } while (*template);
862 *input_template = template;
863 *p = '\0';
864 return ++p;
865 }
866
867 FILE *ruby_popen_writer(char *const *argv, rb_pid_t *pid);
868
869 static FILE *
870 open_report_path(const char *template, char *buf, size_t size, rb_pid_t *pid)
871 {
872 struct report_expansion values = {{0}};
873
874 if (!template) return NULL;
875 if (0) fprintf(stderr, "RUBY_CRASH_REPORT=%s\n", buf);
876 if (*template == '|') {
877 char *argv[16], *bufend = buf + size, *p;
878 int argc;
879 template++;
880 for (argc = 0; argc < numberof(argv) - 1; ++argc) {
881 while (*template && ISSPACE(*template)) template++;
882 p = expand_report_argument(&template, &values, buf, bufend-buf, true);
883 if (!p) break;
884 argv[argc] = buf;
885 buf = p;
886 }
887 argv[argc] = NULL;
888 if (!p) return ruby_popen_writer(argv, pid);
889 }
890 else if (*template) {
891 expand_report_argument(&template, &values, buf, size, false);
892 return fopen(buf, "w");
893 }
894 return NULL;
895 }
896
897 static const char *crash_report;
898
899 /* SIGSEGV handler might have a very small stack. Thus we need to use it carefully. */
900 #define REPORT_BUG_BUFSIZ 256
901 static FILE *
902 bug_report_file(const char *file, int line, rb_pid_t *pid)
903 {
904 char buf[REPORT_BUG_BUFSIZ];
905 const char *report = crash_report;
906 if (!report) report = getenv("RUBY_CRASH_REPORT");
907 FILE *out = open_report_path(report, buf, sizeof(buf), pid);
908 int len = err_position_0(buf, sizeof(buf), file, line);
909
910 if (out) {
911 if ((ssize_t)fwrite(buf, 1, len, out) == (ssize_t)len) return out;
912 fclose(out);
913 }
914 if ((ssize_t)fwrite(buf, 1, len, stderr) == (ssize_t)len) {
915 return stderr;
916 }
917 if ((ssize_t)fwrite(buf, 1, len, stdout) == (ssize_t)len) {
918 return stdout;
919 }
920
921 return NULL;
922 }
923
924 FUNC_MINIMIZED(static void bug_important_message(FILE *out, const char *const msg, size_t len));
925
926 static void
927 bug_important_message(FILE *out, const char *const msg, size_t len)
928 {
929 const char *const endmsg = msg + len;
930 const char *p = msg;
931
932 if (!len) return;
933 if (isatty(fileno(out))) {
934 static const char red[] = "\033[;31;1;7m";
935 static const char green[] = "\033[;32;7m";
936 static const char reset[] = "\033[m";
937 const char *e = strchr(p, '\n');
938 const int w = (int)(e - p);
939 do {
940 int i = (int)(e - p);
941 fputs(*p == ' ' ? green : red, out);
942 fwrite(p, 1, e - p, out);
943 for (; i < w; ++i) fputc(' ', out);
944 fputs(reset, out);
945 fputc('\n', out);
946 } while ((p = e + 1) < endmsg && (e = strchr(p, '\n')) != 0 && e > p + 1);
947 }
948 fwrite(p, 1, endmsg - p, out);
949 }
950
951 #undef CRASH_REPORTER_MAY_BE_CREATED
952 #if defined(__APPLE__) && \
953 (!defined(MAC_OS_X_VERSION_10_6) || MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_6 || defined(__POWERPC__)) /* 10.6 PPC case */
954 # define CRASH_REPORTER_MAY_BE_CREATED
955 #endif
956 static void
957 preface_dump(FILE *out)
958 {
959 #if defined __APPLE__
960 static const char msg[] = ""
961 "-- Crash Report log information "
962 "--------------------------------------------\n"
963 " See Crash Report log file in one of the following locations:\n"
964 # ifdef CRASH_REPORTER_MAY_BE_CREATED
965 " * ~/Library/Logs/CrashReporter\n"
966 " * /Library/Logs/CrashReporter\n"
967 # endif
968 " * ~/Library/Logs/DiagnosticReports\n"
969 " * /Library/Logs/DiagnosticReports\n"
970 " for more details.\n"
971 "Don't forget to include the above Crash Report log file in bug reports.\n"
972 "\n";
973 const size_t msglen = sizeof(msg) - 1;
974 #else
975 const char *msg = NULL;
976 const size_t msglen = 0;
977 #endif
978 bug_important_message(out, msg, msglen);
979 }
980
981 static void
982 postscript_dump(FILE *out)
983 {
984 #if defined __APPLE__
985 static const char msg[] = ""
986 "[IMPORTANT]"
987 /*" ------------------------------------------------"*/
988 "\n""Don't forget to include the Crash Report log file under\n"
989 # ifdef CRASH_REPORTER_MAY_BE_CREATED
990 "CrashReporter or "
991 # endif
992 "DiagnosticReports directory in bug reports.\n"
993 /*"------------------------------------------------------------\n"*/
994 "\n";
995 const size_t msglen = sizeof(msg) - 1;
996 #else
997 const char *msg = NULL;
998 const size_t msglen = 0;
999 #endif
1000 bug_important_message(out, msg, msglen);
1001 }
1002
1003 RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 2, 0)
1004 static void
1005 bug_report_begin_valist(FILE *out, const char *fmt, va_list args)
1006 {
1007 char buf[REPORT_BUG_BUFSIZ];
1008
1009 fputs("[BUG] ", out);
1010 vsnprintf(buf, sizeof(buf), fmt, args);
1011 fputs(buf, out);
1012 snprintf(buf, sizeof(buf), "\n%s\n\n", rb_dynamic_description);
1013 fputs(buf, out);
1014 preface_dump(out);
1015 }
1016
1017 #define bug_report_begin(out, fmt) do { \
1018 va_list args; \
1019 va_start(args, fmt); \
1020 bug_report_begin_valist(out, fmt, args); \
1021 va_end(args); \
1022 } while (0)
1023
1024 static void
1025 bug_report_end(FILE *out, rb_pid_t pid)
1026 {
1027 /* call additional bug reporters */
1028 {
1029 int i;
1030 for (i=0; i<bug_reporters_size; i++) {
1031 struct bug_reporters *reporter = &bug_reporters[i];
1032 (*reporter->func)(out, reporter->data);
1033 }
1034 }
1035 postscript_dump(out);
1036 finish_report(out, pid);
1037 }
1038
1039 #define report_bug(file, line, fmt, ctx) do { \
1040 rb_pid_t pid = -1; \
1041 FILE *out = bug_report_file(file, line, &pid); \
1042 if (out) { \
1043 bug_report_begin(out, fmt); \
1044 rb_vm_bugreport(ctx, out); \
1045 bug_report_end(out, pid); \
1046 } \
1047 } while (0) \
1048
1049 #define report_bug_valist(file, line, fmt, ctx, args) do { \
1050 rb_pid_t pid = -1; \
1051 FILE *out = bug_report_file(file, line, &pid); \
1052 if (out) { \
1053 bug_report_begin_valist(out, fmt, args); \
1054 rb_vm_bugreport(ctx, out); \
1055 bug_report_end(out, pid); \
1056 } \
1057 } while (0) \
1058
1059 void
1060 ruby_set_crash_report(const char *template)
1061 {
1062 crash_report = template;
1063 #if RUBY_DEBUG
1064 rb_pid_t pid = -1;
1065 char buf[REPORT_BUG_BUFSIZ];
1066 FILE *out = open_report_path(template, buf, sizeof(buf), &pid);
1067 if (out) {
1068 time_t t = time(NULL);
1069 fprintf(out, "ruby_test_bug_report: %s", ctime(&t));
1070 finish_report(out, pid);
1071 }
1072 #endif
1073 }
1074
1075 NORETURN(static void die(void));
1076 static void
1077 die(void)
1078 {
1079 #if defined(_WIN32) && defined(RUBY_MSVCRT_VERSION) && RUBY_MSVCRT_VERSION >= 80
1080 _set_abort_behavior( 0, _CALL_REPORTFAULT);
1081 #endif
1082
1083 abort();
1084 }
1085
1086 RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 1, 0)
1087 static void
1088 rb_bug_without_die_internal(const char *fmt, va_list args)
1089 {
1090 const char *file = NULL;
1091 int line = 0;
1092
1093 if (GET_EC()) {
1094 file = rb_source_location_cstr(&line);
1095 }
1096
1097 report_bug_valist(file, line, fmt, NULL, args);
1098 }
1099
1100 RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 1, 0)
1101 void
1102 rb_bug_without_die(const char *fmt, ...)
1103 {
1104 va_list args;
1105 va_start(args, fmt);
1106 rb_bug_without_die_internal(fmt, args);
1107 va_end(args);
1108 }
1109
1110 void
1111 rb_bug(const char *fmt, ...)
1112 {
1113 va_list args;
1114 va_start(args, fmt);
1115 rb_bug_without_die_internal(fmt, args);
1116 va_end(args);
1117 die();
1118 }
1119
1120 void
1121 rb_bug_for_fatal_signal(ruby_sighandler_t default_sighandler, int sig, const void *ctx, const char *fmt, ...)
1122 {
1123 const char *file = NULL;
1124 int line = 0;
1125
1126 if (GET_EC()) {
1127 file = rb_source_location_cstr(&line);
1128 }
1129
1130 report_bug(file, line, fmt, ctx);
1131
1132 if (default_sighandler) default_sighandler(sig);
1133
1134 ruby_default_signal(sig);
1135 die();
1136 }
1137
1138
1139 void
1140 rb_bug_errno(const char *mesg, int errno_arg)
1141 {
1142 if (errno_arg == 0)
1143 rb_bug("%s: errno == 0 (NOERROR)", mesg);
1144 else {
1145 const char *errno_str = rb_strerrno(errno_arg);
1146 if (errno_str)
1147 rb_bug("%s: %s (%s)", mesg, strerror(errno_arg), errno_str);
1148 else
1149 rb_bug("%s: %s (%d)", mesg, strerror(errno_arg), errno_arg);
1150 }
1151 }
1152
1153 /*
1154 * this is safe to call inside signal handler and timer thread
1155 * (which isn't a Ruby Thread object)
1156 */
1157 #define write_or_abort(fd, str, len) (write((fd), (str), (len)) < 0 ? abort() : (void)0)
1158 #define WRITE_CONST(fd,str) write_or_abort((fd),(str),sizeof(str) - 1)
1159
1160 void
1161 rb_async_bug_errno(const char *mesg, int errno_arg)
1162 {
1163 WRITE_CONST(2, "[ASYNC BUG] ");
1164 write_or_abort(2, mesg, strlen(mesg));
1165 WRITE_CONST(2, "\n");
1166
1167 if (errno_arg == 0) {
1168 WRITE_CONST(2, "errno == 0 (NOERROR)\n");
1169 }
1170 else {
1171 const char *errno_str = rb_strerrno(errno_arg);
1172
1173 if (!errno_str)
1174 errno_str = "undefined errno";
1175 write_or_abort(2, errno_str, strlen(errno_str));
1176 }
1177 WRITE_CONST(2, "\n\n");
1178 write_or_abort(2, rb_dynamic_description, strlen(rb_dynamic_description));
1179 abort();
1180 }
1181
1182 void
1183 rb_report_bug_valist(VALUE file, int line, const char *fmt, va_list args)
1184 {
1185 report_bug_valist(RSTRING_PTR(file), line, fmt, NULL, args);
1186 }
1187
1188 void
1189 rb_assert_failure(const char *file, int line, const char *name, const char *expr)
1190 {
1191 rb_assert_failure_detail(file, line, name, expr, NULL);
1192 }
1193
1194 void
1195 rb_assert_failure_detail(const char *file, int line, const char *name, const char *expr,
1196 const char *fmt, ...)
1197 {
1198 rb_pid_t pid = -1;
1199 FILE *out = bug_report_file(file, line, &pid);
1200 if (out) {
1201 fputs("Assertion Failed: ", out);
1202 if (name) fprintf(out, "%s:", name);
1203 fputs(expr, out);
1204
1205 if (fmt && *fmt) {
1206 va_list args;
1207 va_start(args, fmt);
1208 fputs(": ", out);
1209 vfprintf(out, fmt, args);
1210 va_end(args);
1211 }
1212 fprintf(out, "\n%s\n\n", rb_dynamic_description);
1213
1214 preface_dump(out);
1215 rb_vm_bugreport(NULL, out);
1216 bug_report_end(out, pid);
1217 }
1218
1219 die();
1220 }
1221
1222 static const char builtin_types[][10] = {
1223 "", /* 0x00, */
1224 "Object",
1225 "Class",
1226 "Module",
1227 "Float",
1228 "String",
1229 "Regexp",
1230 "Array",
1231 "Hash",
1232 "Struct",
1233 "Integer",
1234 "File",
1235 "Data", /* internal use: wrapped C pointers */
1236 "MatchData", /* data of $~ */
1237 "Complex",
1238 "Rational",
1239 "", /* 0x10 */
1240 "nil",
1241 "true",
1242 "false",
1243 "Symbol", /* :symbol */
1244 "Integer",
1245 "undef", /* internal use: #undef; should not happen */
1246 "", /* 0x17 */
1247 "", /* 0x18 */
1248 "", /* 0x19 */
1249 "<Memo>", /* internal use: general memo */
1250 "<Node>", /* internal use: syntax tree node */
1251 "<iClass>", /* internal use: mixed-in module holder */
1252 };
1253
1254 const char *
1255 rb_builtin_type_name(int t)
1256 {
1257 const char *name;
1258 if ((unsigned int)t >= numberof(builtin_types)) return 0;
1259 name = builtin_types[t];
1260 if (*name) return name;
1261 return 0;
1262 }
1263
1264 static VALUE
1265 displaying_class_of(VALUE x)
1266 {
1267 switch (x) {
1268 case Qfalse: return rb_fstring_cstr("false");
1269 case Qnil: return rb_fstring_cstr("nil");
1270 case Qtrue: return rb_fstring_cstr("true");
1271 default: return rb_obj_class(x);
1272 }
1273 }
1274
1275 static const char *
1276 builtin_class_name(VALUE x)
1277 {
1278 const char *etype;
1279
1280 if (NIL_P(x)) {
1281 etype = "nil";
1282 }
1283 else if (FIXNUM_P(x)) {
1284 etype = "Integer";
1285 }
1286 else if (SYMBOL_P(x)) {
1287 etype = "Symbol";
1288 }
1289 else if (RB_TYPE_P(x, T_TRUE)) {
1290 etype = "true";
1291 }
1292 else if (RB_TYPE_P(x, T_FALSE)) {
1293 etype = "false";
1294 }
1295 else {
1296 etype = NULL;
1297 }
1298 return etype;
1299 }
1300
1301 const char *
1302 rb_builtin_class_name(VALUE x)
1303 {
1304 const char *etype = builtin_class_name(x);
1305
1306 if (!etype) {
1307 etype = rb_obj_classname(x);
1308 }
1309 return etype;
1310 }
1311
1312 COLDFUNC NORETURN(static void unexpected_type(VALUE, int, int));
1313 #define UNDEF_LEAKED "undef leaked to the Ruby space"
1314
1315 static void
1316 unexpected_type(VALUE x, int xt, int t)
1317 {
1318 const char *tname = rb_builtin_type_name(t);
1319 VALUE mesg, exc = rb_eFatal;
1320
1321 if (tname) {
1322 mesg = rb_sprintf("wrong argument type %"PRIsVALUE" (expected %s)",
1323 displaying_class_of(x), tname);
1324 exc = rb_eTypeError;
1325 }
1326 else if (xt > T_MASK && xt <= 0x3f) {
1327 mesg = rb_sprintf("unknown type 0x%x (0x%x given, probably comes"
1328 " from extension library for ruby 1.8)", t, xt);
1329 }
1330 else {
1331 mesg = rb_sprintf("unknown type 0x%x (0x%x given)", t, xt);
1332 }
1333 rb_exc_raise(rb_exc_new_str(exc, mesg));
1334 }
1335
1336 void
1337 rb_check_type(VALUE x, int t)
1338 {
1339 int xt;
1340
1341 if (RB_UNLIKELY(UNDEF_P(x))) {
1342 rb_bug(UNDEF_LEAKED);
1343 }
1344
1345 xt = TYPE(x);
1346 if (xt != t || (xt == T_DATA && rbimpl_rtypeddata_p(x))) {
1347 /*
1348 * Typed data is not simple `T_DATA`, but in a sense an
1349 * extension of `struct RVALUE`, which are incompatible with
1350 * each other except when inherited.
1351 *
1352 * So it is not enough to just check `T_DATA`, it must be
1353 * identified by its `type` using `Check_TypedStruct` instead.
1354 */
1355 unexpected_type(x, xt, t);
1356 }
1357 }
1358
1359 void
1360 rb_unexpected_type(VALUE x, int t)
1361 {
1362 if (RB_UNLIKELY(UNDEF_P(x))) {
1363 rb_bug(UNDEF_LEAKED);
1364 }
1365
1366 unexpected_type(x, TYPE(x), t);
1367 }
1368
1369 int
1370 rb_typeddata_inherited_p(const rb_data_type_t *child, const rb_data_type_t *parent)
1371 {
1372 while (child) {
1373 if (child == parent) return 1;
1374 child = child->parent;
1375 }
1376 return 0;
1377 }
1378
1379 int
1380 rb_typeddata_is_kind_of(VALUE obj, const rb_data_type_t *data_type)
1381 {
1382 if (!RB_TYPE_P(obj, T_DATA) ||
1383 !RTYPEDDATA_P(obj) || !rb_typeddata_inherited_p(RTYPEDDATA_TYPE(obj), data_type)) {
1384 return 0;
1385 }
1386 return 1;
1387 }
1388
1389 #undef rb_typeddata_is_instance_of
1390 int
1391 rb_typeddata_is_instance_of(VALUE obj, const rb_data_type_t *data_type)
1392 {
1393 return rb_typeddata_is_instance_of_inline(obj, data_type);
1394 }
1395
1396 void *
1397 rb_check_typeddata(VALUE obj, const rb_data_type_t *data_type)
1398 {
1399 VALUE actual;
1400
1401 if (!RB_TYPE_P(obj, T_DATA)) {
1402 actual = displaying_class_of(obj);
1403 }
1404 else if (!RTYPEDDATA_P(obj)) {
1405 actual = displaying_class_of(obj);
1406 }
1407 else if (!rb_typeddata_inherited_p(RTYPEDDATA_TYPE(obj), data_type)) {
1408 const char *name = RTYPEDDATA_TYPE(obj)->wrap_struct_name;
1409 actual = rb_str_new_cstr(name); /* or rb_fstring_cstr? not sure... */
1410 }
1411 else {
1412 return RTYPEDDATA_GET_DATA(obj);
1413 }
1414
1415 const char *expected = data_type->wrap_struct_name;
1416 rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE" (expected %s)",
1417 actual, expected);
1418 UNREACHABLE_RETURN(NULL);
1419 }
1420
1421 /* exception classes */
1422 VALUE rb_eException;
1423 VALUE rb_eSystemExit;
1424 VALUE rb_eInterrupt;
1425 VALUE rb_eSignal;
1426 VALUE rb_eFatal;
1427 VALUE rb_eStandardError;
1428 VALUE rb_eRuntimeError;
1429 VALUE rb_eFrozenError;
1430 VALUE rb_eTypeError;
1431 VALUE rb_eArgError;
1432 VALUE rb_eIndexError;
1433 VALUE rb_eKeyError;
1434 VALUE rb_eRangeError;
1435 VALUE rb_eNameError;
1436 VALUE rb_eEncodingError;
1437 VALUE rb_eEncCompatError;
1438 VALUE rb_eNoMethodError;
1439 VALUE rb_eSecurityError;
1440 VALUE rb_eNotImpError;
1441 VALUE rb_eNoMemError;
1442 VALUE rb_cNameErrorMesg;
1443 VALUE rb_eNoMatchingPatternError;
1444 VALUE rb_eNoMatchingPatternKeyError;
1445
1446 VALUE rb_eScriptError;
1447 VALUE rb_eSyntaxError;
1448 VALUE rb_eLoadError;
1449
1450 VALUE rb_eSystemCallError;
1451 VALUE rb_mErrno;
1452 static VALUE rb_eNOERROR;
1453
1454 ID ruby_static_id_cause;
1455 #define id_cause ruby_static_id_cause
1456 static ID id_message, id_detailed_message, id_backtrace;
1457 static ID id_key, id_matchee, id_args, id_Errno, id_errno, id_i_path;
1458 static ID id_receiver, id_recv, id_iseq, id_local_variables;
1459 static ID id_private_call_p, id_top, id_bottom;
1460 #define id_bt idBt
1461 #define id_bt_locations idBt_locations
1462 #define id_mesg idMesg
1463 #define id_name idName
1464
1465 #undef rb_exc_new_cstr
1466
1467 VALUE
1468 rb_exc_new(VALUE etype, const char *ptr, long len)
1469 {
1470 VALUE mesg = rb_str_new(ptr, len);
1471 return rb_class_new_instance(1, &mesg, etype);
1472 }
1473
1474 VALUE
1475 rb_exc_new_cstr(VALUE etype, const char *s)
1476 {
1477 return rb_exc_new(etype, s, strlen(s));
1478 }
1479
1480 VALUE
1481 rb_exc_new_str(VALUE etype, VALUE str)
1482 {
1483 rb_yjit_lazy_push_frame(GET_EC()->cfp->pc);
1484 StringValue(str);
1485 return rb_class_new_instance(1, &str, etype);
1486 }
1487
1488 static VALUE
1489 exc_init(VALUE exc, VALUE mesg)
1490 {
1491 rb_ivar_set(exc, id_mesg, mesg);
1492 rb_ivar_set(exc, id_bt, Qnil);
1493
1494 return exc;
1495 }
1496
1497 /*
1498 * call-seq:
1499 * Exception.new(message = nil) -> exception
1500 *
1501 * Returns a new exception object.
1502 *
1503 * The given +message+ should be
1504 * a {string-convertible object}[rdoc-ref:implicit_conversion.rdoc@String-Convertible+Objects];
1505 * see method #message;
1506 * if not given, the message is the class name of the new instance
1507 * (which may be the name of a subclass):
1508 *
1509 * Examples:
1510 *
1511 * Exception.new # => #<Exception: Exception>
1512 * LoadError.new # => #<LoadError: LoadError> # Subclass of Exception.
1513 * Exception.new('Boom') # => #<Exception: Boom>
1514 *
1515 */
1516
1517 static VALUE
1518 exc_initialize(int argc, VALUE *argv, VALUE exc)
1519 {
1520 VALUE arg;
1521
1522 arg = (!rb_check_arity(argc, 0, 1) ? Qnil : argv[0]);
1523 return exc_init(exc, arg);
1524 }
1525
1526 /*
1527 * Document-method: exception
1528 *
1529 * call-seq:
1530 * exception(message = nil) -> self or new_exception
1531 *
1532 * Returns an exception object of the same class as +self+;
1533 * useful for creating a similar exception, but with a different message.
1534 *
1535 * With +message+ +nil+, returns +self+:
1536 *
1537 * x0 = StandardError.new('Boom') # => #<StandardError: Boom>
1538 * x1 = x0.exception # => #<StandardError: Boom>
1539 * x0.__id__ == x1.__id__ # => true
1540 *
1541 * With {string-convertible object}[rdoc-ref:implicit_conversion.rdoc@String-Convertible+Objects]
1542 * +message+ (even the same as the original message),
1543 * returns a new exception object whose class is the same as +self+,
1544 * and whose message is the given +message+:
1545 *
1546 * x1 = x0.exception('Boom') # => #<StandardError: Boom>
1547 * x0..equal?(x1) # => false
1548 *
1549 */
1550
1551 static VALUE
1552 exc_exception(int argc, VALUE *argv, VALUE self)
1553 {
1554 VALUE exc;
1555
1556 argc = rb_check_arity(argc, 0, 1);
1557 if (argc == 0) return self;
1558 if (argc == 1 && self == argv[0]) return self;
1559 exc = rb_obj_clone(self);
1560 rb_ivar_set(exc, id_mesg, argv[0]);
1561 return exc;
1562 }
1563
1564 /*
1565 * call-seq:
1566 * to_s -> string
1567 *
1568 * Returns a string representation of +self+:
1569 *
1570 * x = RuntimeError.new('Boom')
1571 * x.to_s # => "Boom"
1572 * x = RuntimeError.new
1573 * x.to_s # => "RuntimeError"
1574 *
1575 */
1576
1577 static VALUE
1578 exc_to_s(VALUE exc)
1579 {
1580 VALUE mesg = rb_attr_get(exc, idMesg);
1581
1582 if (NIL_P(mesg)) return rb_class_name(CLASS_OF(exc));
1583 return rb_String(mesg);
1584 }
1585
1586 /* FIXME: Include eval_error.c */
1587 void rb_error_write(VALUE errinfo, VALUE emesg, VALUE errat, VALUE str, VALUE opt, VALUE highlight, VALUE reverse);
1588
1589 VALUE
1590 rb_get_message(VALUE exc)
1591 {
1592 VALUE e = rb_check_funcall(exc, id_message, 0, 0);
1593 if (UNDEF_P(e)) return Qnil;
1594 if (!RB_TYPE_P(e, T_STRING)) e = rb_check_string_type(e);
1595 return e;
1596 }
1597
1598 VALUE
1599 rb_get_detailed_message(VALUE exc, VALUE opt)
1600 {
1601 VALUE e;
1602 if (NIL_P(opt)) {
1603 e = rb_check_funcall(exc, id_detailed_message, 0, 0);
1604 }
1605 else {
1606 e = rb_check_funcall_kw(exc, id_detailed_message, 1, &opt, 1);
1607 }
1608 if (UNDEF_P(e)) return Qnil;
1609 if (!RB_TYPE_P(e, T_STRING)) e = rb_check_string_type(e);
1610 return e;
1611 }
1612
1613 /*
1614 * call-seq:
1615 * Exception.to_tty? -> true or false
1616 *
1617 * Returns +true+ if exception messages will be sent to a terminal device.
1618 */
1619 static VALUE
1620 exc_s_to_tty_p(VALUE self)
1621 {
1622 return RBOOL(rb_stderr_tty_p());
1623 }
1624
1625 static VALUE
1626 check_highlight_keyword(VALUE opt, int auto_tty_detect)
1627 {
1628 VALUE highlight = Qnil;
1629
1630 if (!NIL_P(opt)) {
1631 highlight = rb_hash_lookup(opt, sym_highlight);
1632
1633 switch (highlight) {
1634 default:
1635 rb_bool_expected(highlight, "highlight", TRUE);
1636 UNREACHABLE;
1637 case Qtrue: case Qfalse: case Qnil: break;
1638 }
1639 }
1640
1641 if (NIL_P(highlight)) {
1642 highlight = RBOOL(auto_tty_detect && rb_stderr_tty_p());
1643 }
1644
1645 return highlight;
1646 }
1647
1648 static VALUE
1649 check_order_keyword(VALUE opt)
1650 {
1651 VALUE order = Qnil;
1652
1653 if (!NIL_P(opt)) {
1654 static VALUE kw_order;
1655 if (!kw_order) kw_order = ID2SYM(rb_intern_const("order"));
1656
1657 order = rb_hash_lookup(opt, kw_order);
1658
1659 if (order != Qnil) {
1660 ID id = rb_check_id(&order);
1661 if (id == id_bottom) order = Qtrue;
1662 else if (id == id_top) order = Qfalse;
1663 else {
1664 rb_raise(rb_eArgError, "expected :top or :bottom as "
1665 "order: %+"PRIsVALUE, order);
1666 }
1667 }
1668 }
1669
1670 if (NIL_P(order)) order = Qfalse;
1671
1672 return order;
1673 }
1674
1675 /*
1676 * call-seq:
1677 * full_message(highlight: true, order: :top) -> string
1678 *
1679 * Returns an enhanced message string:
1680 *
1681 * - Includes the exception class name.
1682 * - If the value of keyword +highlight+ is true (not +nil+ or +false+),
1683 * includes bolding ANSI codes (see below) to enhance the appearance of the message.
1684 * - Includes the {backtrace}[rdoc-ref:exceptions.md@Backtraces]:
1685 *
1686 * - If the value of keyword +order+ is +:top+ (the default),
1687 * lists the error message and the innermost backtrace entry first.
1688 * - If the value of keyword +order+ is +:bottom+,
1689 * lists the error message the the innermost entry last.
1690 *
1691 * Example:
1692 *
1693 * def baz
1694 * begin
1695 * 1 / 0
1696 * rescue => x
1697 * pp x.message
1698 * pp x.full_message(highlight: false).split("\n")
1699 * pp x.full_message.split("\n")
1700 * end
1701 * end
1702 * def bar; baz; end
1703 * def foo; bar; end
1704 * foo
1705 *
1706 * Output:
1707 *
1708 * "divided by 0"
1709 * ["t.rb:3:in 'Integer#/': divided by 0 (ZeroDivisionError)",
1710 * "\tfrom t.rb:3:in 'Object#baz'",
1711 * "\tfrom t.rb:10:in 'Object#bar'",
1712 * "\tfrom t.rb:11:in 'Object#foo'",
1713 * "\tfrom t.rb:12:in '<main>'"]
1714 * ["t.rb:3:in 'Integer#/': \e[1mdivided by 0 (\e[1;4mZeroDivisionError\e[m\e[1m)\e[m",
1715 * "\tfrom t.rb:3:in 'Object#baz'",
1716 * "\tfrom t.rb:10:in 'Object#bar'",
1717 * "\tfrom t.rb:11:in 'Object#foo'",
1718 * "\tfrom t.rb:12:in '<main>'"]
1719 *
1720 * An overriding method should be careful with ANSI code enhancements;
1721 * see {Messages}[rdoc-ref:exceptions.md@Messages].
1722 */
1723
1724 static VALUE
1725 exc_full_message(int argc, VALUE *argv, VALUE exc)
1726 {
1727 VALUE opt, str, emesg, errat;
1728 VALUE highlight, order;
1729
1730 rb_scan_args(argc, argv, "0:", &opt);
1731
1732 highlight = check_highlight_keyword(opt, 1);
1733 order = check_order_keyword(opt);
1734
1735 {
1736 if (NIL_P(opt)) opt = rb_hash_new();
1737 rb_hash_aset(opt, sym_highlight, highlight);
1738 }
1739
1740 str = rb_str_new2("");
1741 errat = rb_get_backtrace(exc);
1742 emesg = rb_get_detailed_message(exc, opt);
1743
1744 rb_error_write(exc, emesg, errat, str, opt, highlight, order);
1745 return str;
1746 }
1747
1748 /*
1749 * call-seq:
1750 * message -> string
1751 *
1752 * Returns #to_s.
1753 *
1754 * See {Messages}[rdoc-ref:exceptions.md@Messages].
1755 */
1756
1757 static VALUE
1758 exc_message(VALUE exc)
1759 {
1760 return rb_funcallv(exc, idTo_s, 0, 0);
1761 }
1762
1763 /*
1764 * call-seq:
1765 * detailed_message(highlight: false, **kwargs) -> string
1766 *
1767 * Returns the message string with enhancements:
1768 *
1769 * - Includes the exception class name in the first line.
1770 * - If the value of keyword +highlight+ is +true+,
1771 * includes bolding and underlining ANSI codes (see below)
1772 * to enhance the appearance of the message.
1773 *
1774 * Examples:
1775 *
1776 * begin
1777 * 1 / 0
1778 * rescue => x
1779 * p x.message
1780 * p x.detailed_message # Class name added.
1781 * p x.detailed_message(highlight: true) # Class name, bolding, and underlining added.
1782 * end
1783 *
1784 * Output:
1785 *
1786 * "divided by 0"
1787 * "divided by 0 (ZeroDivisionError)"
1788 * "\e[1mdivided by 0 (\e[1;4mZeroDivisionError\e[m\e[1m)\e[m"
1789 *
1790 * This method is overridden by some gems in the Ruby standard library to add information:
1791 *
1792 * - DidYouMean::Correctable#detailed_message.
1793 * - ErrorHighlight::CoreExt#detailed_message.
1794 * - SyntaxSuggest#detailed_message.
1795 *
1796 * An overriding method must be tolerant of passed keyword arguments,
1797 * which may include (but may not be limited to):
1798 *
1799 * - +:highlight+.
1800 * - +:did_you_mean+.
1801 * - +:error_highlight+.
1802 * - +:syntax_suggest+.
1803 *
1804 * An overriding method should also be careful with ANSI code enhancements;
1805 * see {Messages}[rdoc-ref:exceptions.md@Messages].
1806 */
1807
1808 static VALUE
1809 exc_detailed_message(int argc, VALUE *argv, VALUE exc)
1810 {
1811 VALUE opt;
1812
1813 rb_scan_args(argc, argv, "0:", &opt);
1814
1815 VALUE highlight = check_highlight_keyword(opt, 0);
1816
1817 extern VALUE rb_decorate_message(const VALUE eclass, VALUE emesg, int highlight);
1818
1819 return rb_decorate_message(CLASS_OF(exc), rb_get_message(exc), RTEST(highlight));
1820 }
1821
1822 /*
1823 * call-seq:
1824 * inspect -> string
1825 *
1826 * Returns a string representation of +self+:
1827 *
1828 * x = RuntimeError.new('Boom')
1829 * x.inspect # => "#<RuntimeError: Boom>"
1830 * x = RuntimeError.new
1831 * x.inspect # => "#<RuntimeError: RuntimeError>"
1832 *
1833 */
1834
1835 static VALUE
1836 exc_inspect(VALUE exc)
1837 {
1838 VALUE str, klass;
1839
1840 klass = CLASS_OF(exc);
1841 exc = rb_obj_as_string(exc);
1842 if (RSTRING_LEN(exc) == 0) {
1843 return rb_class_name(klass);
1844 }
1845
1846 str = rb_str_buf_new2("#<");
1847 klass = rb_class_name(klass);
1848 rb_str_buf_append(str, klass);
1849
1850 if (RTEST(rb_str_include(exc, rb_str_new2("\n")))) {
1851 rb_str_catf(str, ":%+"PRIsVALUE, exc);
1852 }
1853 else {
1854 rb_str_buf_cat(str, ": ", 2);
1855 rb_str_buf_append(str, exc);
1856 }
1857
1858 rb_str_buf_cat(str, ">", 1);
1859
1860 return str;
1861 }
1862
1863 /*
1864 * call-seq:
1865 * backtrace -> array or nil
1866 *
1867 * Returns the backtrace (the list of code locations that led to the exception),
1868 * as an array of strings.
1869 *
1870 * Example (assuming the code is stored in the file named <tt>t.rb</tt>):
1871 *
1872 * def division(numerator, denominator)
1873 * numerator / denominator
1874 * end
1875 *
1876 * begin
1877 * division(1, 0)
1878 * rescue => ex
1879 * p ex.backtrace
1880 * # ["t.rb:2:in 'Integer#/'", "t.rb:2:in 'Object#division'", "t.rb:6:in '<main>'"]
1881 * loc = ex.backtrace.first
1882 * p loc.class
1883 * # String
1884 * end
1885 *
1886 * The value returned by this method migth be adjusted when raising (see Kernel#raise),
1887 * or during intermediate handling by #set_backtrace.
1888 *
1889 * See also #backtrace_locations that provide the same value, as structured objects.
1890 * (Note though that two values might not be consistent with each other when
1891 * backtraces are manually adjusted.)
1892 *
1893 * see {Backtraces}[rdoc-ref:exceptions.md@Backtraces].
1894 */
1895
1896 static VALUE
1897 exc_backtrace(VALUE exc)
1898 {
1899 VALUE obj;
1900
1901 obj = rb_attr_get(exc, id_bt);
1902
1903 if (rb_backtrace_p(obj)) {
1904 obj = rb_backtrace_to_str_ary(obj);
1905 /* rb_ivar_set(exc, id_bt, obj); */
1906 }
1907
1908 return obj;
1909 }
1910
1911 static VALUE rb_check_backtrace(VALUE);
1912
1913 VALUE
1914 rb_get_backtrace(VALUE exc)
1915 {
1916 ID mid = id_backtrace;
1917 VALUE info;
1918 if (rb_method_basic_definition_p(CLASS_OF(exc), id_backtrace)) {
1919 VALUE klass = rb_eException;
1920 rb_execution_context_t *ec = GET_EC();
1921 if (NIL_P(exc))
1922 return Qnil;
1923 EXEC_EVENT_HOOK(ec, RUBY_EVENT_C_CALL, exc, mid, mid, klass, Qundef);
1924 info = exc_backtrace(exc);
1925 EXEC_EVENT_HOOK(ec, RUBY_EVENT_C_RETURN, exc, mid, mid, klass, info);
1926 }
1927 else {
1928 info = rb_funcallv(exc, mid, 0, 0);
1929 }
1930 if (NIL_P(info)) return Qnil;
1931 return rb_check_backtrace(info);
1932 }
1933
1934 /*
1935 * call-seq:
1936 * backtrace_locations -> array or nil
1937 *
1938 * Returns the backtrace (the list of code locations that led to the exception),
1939 * as an array of Thread::Backtrace::Location instances.
1940 *
1941 * Example (assuming the code is stored in the file named <tt>t.rb</tt>):
1942 *
1943 * def division(numerator, denominator)
1944 * numerator / denominator
1945 * end
1946 *
1947 * begin
1948 * division(1, 0)
1949 * rescue => ex
1950 * p ex.backtrace_locations
1951 * # ["t.rb:2:in 'Integer#/'", "t.rb:2:in 'Object#division'", "t.rb:6:in '<main>'"]
1952 * loc = ex.backtrace_locations.first
1953 * p loc.class
1954 * # Thread::Backtrace::Location
1955 * p loc.path
1956 * # "t.rb"
1957 * p loc.lineno
1958 * # 2
1959 * p loc.label
1960 * # "Integer#/"
1961 * end
1962 *
1963 * The value returned by this method might be adjusted when raising (see Kernel#raise),
1964 * or during intermediate handling by #set_backtrace.
1965 *
1966 * See also #backtrace that provide the same value as an array of strings.
1967 * (Note though that two values might not be consistent with each other when
1968 * backtraces are manually adjusted.)
1969 *
1970 * See {Backtraces}[rdoc-ref:exceptions.md@Backtraces].
1971 */
1972 static VALUE
1973 exc_backtrace_locations(VALUE exc)
1974 {
1975 VALUE obj;
1976
1977 obj = rb_attr_get(exc, id_bt_locations);
1978 if (!NIL_P(obj)) {
1979 obj = rb_backtrace_to_location_ary(obj);
1980 }
1981 return obj;
1982 }
1983
1984 static VALUE
1985 rb_check_backtrace(VALUE bt)
1986 {
1987 long i;
1988 static const char err[] = "backtrace must be an Array of String or an Array of Thread::Backtrace::Location";
1989
1990 if (!NIL_P(bt)) {
1991 if (RB_TYPE_P(bt, T_STRING)) return rb_ary_new3(1, bt);
1992 if (rb_backtrace_p(bt)) return bt;
1993 if (!RB_TYPE_P(bt, T_ARRAY)) {
1994 rb_raise(rb_eTypeError, err);
1995 }
1996 for (i=0;i<RARRAY_LEN(bt);i++) {
1997 VALUE e = RARRAY_AREF(bt, i);
1998 if (!RB_TYPE_P(e, T_STRING)) {
1999 rb_raise(rb_eTypeError, err);
2000 }
2001 }
2002 }
2003 return bt;
2004 }
2005
2006 /*
2007 * call-seq:
2008 * set_backtrace(value) -> value
2009 *
2010 * Sets the backtrace value for +self+; returns the given +value+.
2011 *
2012 * The +value+ might be:
2013 *
2014 * - an array of Thread::Backtrace::Location;
2015 * - an array of String instances;
2016 * - a single String instance; or
2017 * - +nil+.
2018 *
2019 * Using array of Thread::Backtrace::Location is the most consistent
2020 * option: it sets both #backtrace and #backtrace_locations. It should be
2021 * preferred when possible. The suitable array of locations can be obtained
2022 * from Kernel#caller_locations, copied from another error, or just set to
2023 * the adjusted result of the current error's #backtrace_locations:
2024 *
2025 * require 'json'
2026 *
2027 * def parse_payload(text)
2028 * JSON.parse(text) # test.rb, line 4
2029 * rescue JSON::ParserError => ex
2030 * ex.set_backtrace(ex.backtrace_locations[2...])
2031 * raise
2032 * end
2033 *
2034 * parse_payload('{"wrong: "json"')
2035 * # test.rb:4:in 'Object#parse_payload': unexpected token at '{"wrong: "json"' (JSON::ParserError)
2036 * #
2037 * # An error points to the body of parse_payload method,
2038 * # hiding the parts of the backtrace related to the internals
2039 * # of the "json" library
2040 *
2041 * # The error has both #backtace and #backtrace_locations set
2042 * # consistently:
2043 * begin
2044 * parse_payload('{"wrong: "json"')
2045 * rescue => ex
2046 * p ex.backtrace
2047 * # ["test.rb:4:in 'Object#parse_payload'", "test.rb:20:in '<main>'"]
2048 * p ex.backtrace_locations
2049 * # ["test.rb:4:in 'Object#parse_payload'", "test.rb:20:in '<main>'"]
2050 * end
2051 *
2052 * When the desired stack of locations is not available and should
2053 * be constructed from scratch, an array of strings or a singular
2054 * string can be used. In this case, only #backtrace is affected:
2055 *
2056 * def parse_payload(text)
2057 * JSON.parse(text)
2058 * rescue JSON::ParserError => ex
2059 * ex.set_backtrace(["dsl.rb:34", "framework.rb:1"])
2060 * # The error have the new value in #backtrace:
2061 * p ex.backtrace
2062 * # ["dsl.rb:34", "framework.rb:1"]
2063 *
2064 * # but the original one in #backtrace_locations
2065 * p ex.backtrace_locations
2066 * # [".../json/common.rb:221:in 'JSON::Ext::Parser.parse'", ...]
2067 * end
2068 *
2069 * parse_payload('{"wrong: "json"')
2070 *
2071 * Calling #set_backtrace with +nil+ clears up #backtrace but doesn't affect
2072 * #backtrace_locations:
2073 *
2074 * def parse_payload(text)
2075 * JSON.parse(text)
2076 * rescue JSON::ParserError => ex
2077 * ex.set_backtrace(nil)
2078 * p ex.backtrace
2079 * # nil
2080 * p ex.backtrace_locations
2081 * # [".../json/common.rb:221:in 'JSON::Ext::Parser.parse'", ...]
2082 * end
2083 *
2084 * parse_payload('{"wrong: "json"')
2085 *
2086 * On reraising of such an exception, both #backtrace and #backtrace_locations
2087 * is set to the place of reraising:
2088 *
2089 * def parse_payload(text)
2090 * JSON.parse(text)
2091 * rescue JSON::ParserError => ex
2092 * ex.set_backtrace(nil)
2093 * raise # test.rb, line 7
2094 * end
2095 *
2096 * begin
2097 * parse_payload('{"wrong: "json"')
2098 * rescue => ex
2099 * p ex.backtrace
2100 * # ["test.rb:7:in 'Object#parse_payload'", "test.rb:11:in '<main>'"]
2101 * p ex.backtrace_locations
2102 * # ["test.rb:7:in 'Object#parse_payload'", "test.rb:11:in '<main>'"]
2103 * end
2104 *
2105 * See {Backtraces}[rdoc-ref:exceptions.md@Backtraces].
2106 */
2107
2108 static VALUE
2109 exc_set_backtrace(VALUE exc, VALUE bt)
2110 {
2111 VALUE btobj = rb_location_ary_to_backtrace(bt);
2112 if (RTEST(btobj)) {
2113 rb_ivar_set(exc, id_bt, btobj);
2114 rb_ivar_set(exc, id_bt_locations, btobj);
2115 return bt;
2116 }
2117 else {
2118 return rb_ivar_set(exc, id_bt, rb_check_backtrace(bt));
2119 }
2120 }
2121
2122 VALUE
2123 rb_exc_set_backtrace(VALUE exc, VALUE bt)
2124 {
2125 return exc_set_backtrace(exc, bt);
2126 }
2127
2128 /*
2129 * call-seq:
2130 * cause -> exception or nil
2131 *
2132 * Returns the previous value of global variable <tt>$!</tt>,
2133 * which may be +nil+
2134 * (see {Global Variables}[rdoc-ref:exceptions.md@Global+Variables]):
2135 *
2136 * begin
2137 * raise('Boom 0')
2138 * rescue => x0
2139 * puts "Exception: #{x0}; $!: #{$!}; cause: #{x0.cause.inspect}."
2140 * begin
2141 * raise('Boom 1')
2142 * rescue => x1
2143 * puts "Exception: #{x1}; $!: #{$!}; cause: #{x1.cause}."
2144 * begin
2145 * raise('Boom 2')
2146 * rescue => x2
2147 * puts "Exception: #{x2}; $!: #{$!}; cause: #{x2.cause}."
2148 * end
2149 * end
2150 * end
2151 *
2152 * Output:
2153 *
2154 * Exception: Boom 0; $!: Boom 0; cause: nil.
2155 * Exception: Boom 1; $!: Boom 1; cause: Boom 0.
2156 * Exception: Boom 2; $!: Boom 2; cause: Boom 1.
2157 *
2158 */
2159
2160 static VALUE
2161 exc_cause(VALUE exc)
2162 {
2163 return rb_attr_get(exc, id_cause);
2164 }
2165
2166 static VALUE
2167 try_convert_to_exception(VALUE obj)
2168 {
2169 return rb_check_funcall(obj, idException, 0, 0);
2170 }
2171
2172 /*
2173 * call-seq:
2174 * self == object -> true or false
2175 *
2176 * Returns whether +object+ is the same class as +self+
2177 * and its #message and #backtrace are equal to those of +self+.
2178 *
2179 */
2180
2181 static VALUE
2182 exc_equal(VALUE exc, VALUE obj)
2183 {
2184 VALUE mesg, backtrace;
2185
2186 if (exc == obj) return Qtrue;
2187
2188 if (rb_obj_class(exc) != rb_obj_class(obj)) {
2189 int state;
2190
2191 obj = rb_protect(try_convert_to_exception, obj, &state);
2192 if (state || UNDEF_P(obj)) {
2193 rb_set_errinfo(Qnil);
2194 return Qfalse;
2195 }
2196 if (rb_obj_class(exc) != rb_obj_class(obj)) return Qfalse;
2197 mesg = rb_check_funcall(obj, id_message, 0, 0);
2198 if (UNDEF_P(mesg)) return Qfalse;
2199 backtrace = rb_check_funcall(obj, id_backtrace, 0, 0);
2200 if (UNDEF_P(backtrace)) return Qfalse;
2201 }
2202 else {
2203 mesg = rb_attr_get(obj, id_mesg);
2204 backtrace = exc_backtrace(obj);
2205 }
2206
2207 if (!rb_equal(rb_attr_get(exc, id_mesg), mesg))
2208 return Qfalse;
2209 return rb_equal(exc_backtrace(exc), backtrace);
2210 }
2211
2212 /*
2213 * call-seq:
2214 * SystemExit.new -> system_exit
2215 * SystemExit.new(status) -> system_exit
2216 * SystemExit.new(status, msg) -> system_exit
2217 * SystemExit.new(msg) -> system_exit
2218 *
2219 * Create a new +SystemExit+ exception with the given status and message.
2220 * Status is true, false, or an integer.
2221 * If status is not given, true is used.
2222 */
2223
2224 static VALUE
2225 exit_initialize(int argc, VALUE *argv, VALUE exc)
2226 {
2227 VALUE status;
2228 if (argc > 0) {
2229 status = *argv;
2230
2231 switch (status) {
2232 case Qtrue:
2233 status = INT2FIX(EXIT_SUCCESS);
2234 ++argv;
2235 --argc;
2236 break;
2237 case Qfalse:
2238 status = INT2FIX(EXIT_FAILURE);
2239 ++argv;
2240 --argc;
2241 break;
2242 default:
2243 status = rb_check_to_int(status);
2244 if (NIL_P(status)) {
2245 status = INT2FIX(EXIT_SUCCESS);
2246 }
2247 else {
2248 #if EXIT_SUCCESS != 0
2249 if (status == INT2FIX(0))
2250 status = INT2FIX(EXIT_SUCCESS);
2251 #endif
2252 ++argv;
2253 --argc;
2254 }
2255 break;
2256 }
2257 }
2258 else {
2259 status = INT2FIX(EXIT_SUCCESS);
2260 }
2261 rb_call_super(argc, argv);
2262 rb_ivar_set(exc, id_status, status);
2263 return exc;
2264 }
2265
2266
2267 /*
2268 * call-seq:
2269 * system_exit.status -> integer
2270 *
2271 * Return the status value associated with this system exit.
2272 */
2273
2274 static VALUE
2275 exit_status(VALUE exc)
2276 {
2277 return rb_attr_get(exc, id_status);
2278 }
2279
2280
2281 /*
2282 * call-seq:
2283 * system_exit.success? -> true or false
2284 *
2285 * Returns +true+ if exiting successful, +false+ if not.
2286 */
2287
2288 static VALUE
2289 exit_success_p(VALUE exc)
2290 {
2291 VALUE status_val = rb_attr_get(exc, id_status);
2292 int status;
2293
2294 if (NIL_P(status_val))
2295 return Qtrue;
2296 status = NUM2INT(status_val);
2297 return RBOOL(WIFEXITED(status) && WEXITSTATUS(status) == EXIT_SUCCESS);
2298 }
2299
2300 static VALUE
2301 err_init_recv(VALUE exc, VALUE recv)
2302 {
2303 if (!UNDEF_P(recv)) rb_ivar_set(exc, id_recv, recv);
2304 return exc;
2305 }
2306
2307 /*
2308 * call-seq:
2309 * FrozenError.new(msg=nil, receiver: nil) -> frozen_error
2310 *
2311 * Construct a new FrozenError exception. If given the <i>receiver</i>
2312 * parameter may subsequently be examined using the FrozenError#receiver
2313 * method.
2314 *
2315 * a = [].freeze
2316 * raise FrozenError.new("can't modify frozen array", receiver: a)
2317 */
2318
2319 static VALUE
2320 frozen_err_initialize(int argc, VALUE *argv, VALUE self)
2321 {
2322 ID keywords[1];
2323 VALUE values[numberof(keywords)], options;
2324
2325 argc = rb_scan_args(argc, argv, "*:", NULL, &options);
2326 keywords[0] = id_receiver;
2327 rb_get_kwargs(options, keywords, 0, numberof(values), values);
2328 rb_call_super(argc, argv);
2329 err_init_recv(self, values[0]);
2330 return self;
2331 }
2332
2333 /*
2334 * Document-method: FrozenError#receiver
2335 * call-seq:
2336 * frozen_error.receiver -> object
2337 *
2338 * Return the receiver associated with this FrozenError exception.
2339 */
2340
2341 #define frozen_err_receiver name_err_receiver
2342
2343 void
2344 rb_name_error(ID id, const char *fmt, ...)
2345 {
2346 VALUE exc, argv[2];
2347 va_list args;
2348
2349 va_start(args, fmt);
2350 argv[0] = rb_vsprintf(fmt, args);
2351 va_end(args);
2352
2353 argv[1] = ID2SYM(id);
2354 exc = rb_class_new_instance(2, argv, rb_eNameError);
2355 rb_exc_raise(exc);
2356 }
2357
2358 void
2359 rb_name_error_str(VALUE str, const char *fmt, ...)
2360 {
2361 VALUE exc, argv[2];
2362 va_list args;
2363
2364 va_start(args, fmt);
2365 argv[0] = rb_vsprintf(fmt, args);
2366 va_end(args);
2367
2368 argv[1] = str;
2369 exc = rb_class_new_instance(2, argv, rb_eNameError);
2370 rb_exc_raise(exc);
2371 }
2372
2373 static VALUE
2374 name_err_init_attr(VALUE exc, VALUE recv, VALUE method)
2375 {
2376 const rb_execution_context_t *ec = GET_EC();
2377 rb_control_frame_t *cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(ec->cfp);
2378 cfp = rb_vm_get_ruby_level_next_cfp(ec, cfp);
2379 rb_ivar_set(exc, id_name, method);
2380 err_init_recv(exc, recv);
2381 if (cfp && VM_FRAME_TYPE(cfp) != VM_FRAME_MAGIC_DUMMY) {
2382 rb_ivar_set(exc, id_iseq, rb_iseqw_new(cfp->iseq));
2383 }
2384 return exc;
2385 }
2386
2387 /*
2388 * call-seq:
2389 * NameError.new(msg=nil, name=nil, receiver: nil) -> name_error
2390 *
2391 * Construct a new NameError exception. If given the <i>name</i>
2392 * parameter may subsequently be examined using the NameError#name
2393 * method. <i>receiver</i> parameter allows to pass object in
2394 * context of which the error happened. Example:
2395 *
2396 * [1, 2, 3].method(:rject) # NameError with name "rject" and receiver: Array
2397 * [1, 2, 3].singleton_method(:rject) # NameError with name "rject" and receiver: [1, 2, 3]
2398 */
2399
2400 static VALUE
2401 name_err_initialize(int argc, VALUE *argv, VALUE self)
2402 {
2403 ID keywords[1];
2404 VALUE values[numberof(keywords)], name, options;
2405
2406 argc = rb_scan_args(argc, argv, "*:", NULL, &options);
2407 keywords[0] = id_receiver;
2408 rb_get_kwargs(options, keywords, 0, numberof(values), values);
2409 name = (argc > 1) ? argv[--argc] : Qnil;
2410 rb_call_super(argc, argv);
2411 name_err_init_attr(self, values[0], name);
2412 return self;
2413 }
2414
2415 static VALUE rb_name_err_mesg_new(VALUE mesg, VALUE recv, VALUE method);
2416
2417 static VALUE
2418 name_err_init(VALUE exc, VALUE mesg, VALUE recv, VALUE method)
2419 {
2420 exc_init(exc, rb_name_err_mesg_new(mesg, recv, method));
2421 return name_err_init_attr(exc, recv, method);
2422 }
2423
2424 VALUE
2425 rb_name_err_new(VALUE mesg, VALUE recv, VALUE method)
2426 {
2427 VALUE exc = rb_obj_alloc(rb_eNameError);
2428 return name_err_init(exc, mesg, recv, method);
2429 }
2430
2431 /*
2432 * call-seq:
2433 * name_error.name -> string or nil
2434 *
2435 * Return the name associated with this NameError exception.
2436 */
2437
2438 static VALUE
2439 name_err_name(VALUE self)
2440 {
2441 return rb_attr_get(self, id_name);
2442 }
2443
2444 /*
2445 * call-seq:
2446 * name_error.local_variables -> array
2447 *
2448 * Return a list of the local variable names defined where this
2449 * NameError exception was raised.
2450 *
2451 * Internal use only.
2452 */
2453
2454 static VALUE
2455 name_err_local_variables(VALUE self)
2456 {
2457 VALUE vars = rb_attr_get(self, id_local_variables);
2458
2459 if (NIL_P(vars)) {
2460 VALUE iseqw = rb_attr_get(self, id_iseq);
2461 if (!NIL_P(iseqw)) vars = rb_iseqw_local_variables(iseqw);
2462 if (NIL_P(vars)) vars = rb_ary_new();
2463 rb_ivar_set(self, id_local_variables, vars);
2464 }
2465 return vars;
2466 }
2467
2468 static VALUE
2469 nometh_err_init_attr(VALUE exc, VALUE args, int priv)
2470 {
2471 rb_ivar_set(exc, id_args, args);
2472 rb_ivar_set(exc, id_private_call_p, RBOOL(priv));
2473 return exc;
2474 }
2475
2476 /*
2477 * call-seq:
2478 * NoMethodError.new(msg=nil, name=nil, args=nil, private=false, receiver: nil) -> no_method_error
2479 *
2480 * Construct a NoMethodError exception for a method of the given name
2481 * called with the given arguments. The name may be accessed using
2482 * the <code>#name</code> method on the resulting object, and the
2483 * arguments using the <code>#args</code> method.
2484 *
2485 * If <i>private</i> argument were passed, it designates method was
2486 * attempted to call in private context, and can be accessed with
2487 * <code>#private_call?</code> method.
2488 *
2489 * <i>receiver</i> argument stores an object whose method was called.
2490 */
2491
2492 static VALUE
2493 nometh_err_initialize(int argc, VALUE *argv, VALUE self)
2494 {
2495 int priv;
2496 VALUE args, options;
2497 argc = rb_scan_args(argc, argv, "*:", NULL, &options);
2498 priv = (argc > 3) && (--argc, RTEST(argv[argc]));
2499 args = (argc > 2) ? argv[--argc] : Qnil;
2500 if (!NIL_P(options)) argv[argc++] = options;
2501 rb_call_super_kw(argc, argv, RB_PASS_CALLED_KEYWORDS);
2502 return nometh_err_init_attr(self, args, priv);
2503 }
2504
2505 VALUE
2506 rb_nomethod_err_new(VALUE mesg, VALUE recv, VALUE method, VALUE args, int priv)
2507 {
2508 VALUE exc = rb_obj_alloc(rb_eNoMethodError);
2509 name_err_init(exc, mesg, recv, method);
2510 return nometh_err_init_attr(exc, args, priv);
2511 }
2512
2513 typedef struct name_error_message_struct {
2514 VALUE mesg;
2515 VALUE recv;
2516 VALUE name;
2517 } name_error_message_t;
2518
2519 static void
2520 name_err_mesg_mark(void *p)
2521 {
2522 name_error_message_t *ptr = (name_error_message_t *)p;
2523 rb_gc_mark_movable(ptr->mesg);
2524 rb_gc_mark_movable(ptr->recv);
2525 rb_gc_mark_movable(ptr->name);
2526 }
2527
2528 static void
2529 name_err_mesg_update(void *p)
2530 {
2531 name_error_message_t *ptr = (name_error_message_t *)p;
2532 ptr->mesg = rb_gc_location(ptr->mesg);
2533 ptr->recv = rb_gc_location(ptr->recv);
2534 ptr->name = rb_gc_location(ptr->name);
2535 }
2536
2537 static const rb_data_type_t name_err_mesg_data_type = {
2538 "name_err_mesg",
2539 {
2540 name_err_mesg_mark,
2541 RUBY_TYPED_DEFAULT_FREE,
2542 NULL, // No external memory to report,
2543 name_err_mesg_update,
2544 },
2545 0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_EMBEDDABLE
2546 };
2547
2548 /* :nodoc: */
2549 static VALUE
2550 rb_name_err_mesg_init(VALUE klass, VALUE mesg, VALUE recv, VALUE name)
2551 {
2552 name_error_message_t *message;
2553 VALUE result = TypedData_Make_Struct(klass, name_error_message_t, &name_err_mesg_data_type, message);
2554 RB_OBJ_WRITE(result, &message->mesg, mesg);
2555 RB_OBJ_WRITE(result, &message->recv, recv);
2556 RB_OBJ_WRITE(result, &message->name, name);
2557 return result;
2558 }
2559
2560 /* :nodoc: */
2561 static VALUE
2562 rb_name_err_mesg_new(VALUE mesg, VALUE recv, VALUE method)
2563 {
2564 return rb_name_err_mesg_init(rb_cNameErrorMesg, mesg, recv, method);
2565 }
2566
2567 /* :nodoc: */
2568 static VALUE
2569 name_err_mesg_alloc(VALUE klass)
2570 {
2571 return rb_name_err_mesg_init(klass, Qnil, Qnil, Qnil);
2572 }
2573
2574 /* :nodoc: */
2575 static VALUE
2576 name_err_mesg_init_copy(VALUE obj1, VALUE obj2)
2577 {
2578 if (obj1 == obj2) return obj1;
2579 rb_obj_init_copy(obj1, obj2);
2580
2581 name_error_message_t *ptr1, *ptr2;
2582 TypedData_Get_Struct(obj1, name_error_message_t, &name_err_mesg_data_type, ptr1);
2583 TypedData_Get_Struct(obj2, name_error_message_t, &name_err_mesg_data_type, ptr2);
2584
2585 RB_OBJ_WRITE(obj1, &ptr1->mesg, ptr2->mesg);
2586 RB_OBJ_WRITE(obj1, &ptr1->recv, ptr2->recv);
2587 RB_OBJ_WRITE(obj1, &ptr1->name, ptr2->name);
2588 return obj1;
2589 }
2590
2591 /* :nodoc: */
2592 static VALUE
2593 name_err_mesg_equal(VALUE obj1, VALUE obj2)
2594 {
2595 if (obj1 == obj2) return Qtrue;
2596
2597 if (rb_obj_class(obj2) != rb_cNameErrorMesg)
2598 return Qfalse;
2599
2600 name_error_message_t *ptr1, *ptr2;
2601 TypedData_Get_Struct(obj1, name_error_message_t, &name_err_mesg_data_type, ptr1);
2602 TypedData_Get_Struct(obj2, name_error_message_t, &name_err_mesg_data_type, ptr2);
2603
2604 if (!rb_equal(ptr1->mesg, ptr2->mesg)) return Qfalse;
2605 if (!rb_equal(ptr1->recv, ptr2->recv)) return Qfalse;
2606 if (!rb_equal(ptr1->name, ptr2->name)) return Qfalse;
2607 return Qtrue;
2608 }
2609
2610 /* :nodoc: */
2611 static VALUE
2612 name_err_mesg_receiver_name(VALUE obj)
2613 {
2614 if (RB_SPECIAL_CONST_P(obj)) return Qundef;
2615 if (RB_BUILTIN_TYPE(obj) == T_MODULE || RB_BUILTIN_TYPE(obj) == T_CLASS) {
2616 return rb_check_funcall(obj, rb_intern("name"), 0, 0);
2617 }
2618 return Qundef;
2619 }
2620
2621 /* :nodoc: */
2622 static VALUE
2623 name_err_mesg_to_str(VALUE obj)
2624 {
2625 name_error_message_t *ptr;
2626 TypedData_Get_Struct(obj, name_error_message_t, &name_err_mesg_data_type, ptr);
2627
2628 VALUE mesg = ptr->mesg;
2629 if (NIL_P(mesg)) return Qnil;
2630 else {
2631 struct RString s_str, c_str, d_str;
2632 VALUE c, s, d = 0, args[4], c2;
2633 int state = 0;
2634 rb_encoding *usascii = rb_usascii_encoding();
2635
2636 #define FAKE_CSTR(v, str) rb_setup_fake_str((v), (str), rb_strlen_lit(str), usascii)
2637 c = s = FAKE_CSTR(&s_str, "");
2638 obj = ptr->recv;
2639 switch (obj) {
2640 case Qnil:
2641 c = d = FAKE_CSTR(&d_str, "nil");
2642 break;
2643 case Qtrue:
2644 c = d = FAKE_CSTR(&d_str, "true");
2645 break;
2646 case Qfalse:
2647 c = d = FAKE_CSTR(&d_str, "false");
2648 break;
2649 default:
2650 if (strstr(RSTRING_PTR(mesg), "%2$s")) {
2651 d = rb_protect(name_err_mesg_receiver_name, obj, &state);
2652 if (state || NIL_OR_UNDEF_P(d))
2653 d = rb_protect(rb_inspect, obj, &state);
2654 if (state) {
2655 rb_set_errinfo(Qnil);
2656 }
2657 d = rb_check_string_type(d);
2658 if (NIL_P(d)) {
2659 d = rb_any_to_s(obj);
2660 }
2661 }
2662
2663 if (!RB_SPECIAL_CONST_P(obj)) {
2664 switch (RB_BUILTIN_TYPE(obj)) {
2665 case T_MODULE:
2666 s = FAKE_CSTR(&s_str, "module ");
2667 c = obj;
2668 break;
2669 case T_CLASS:
2670 s = FAKE_CSTR(&s_str, "class ");
2671 c = obj;
2672 break;
2673 default:
2674 goto object;
2675 }
2676 }
2677 else {
2678 VALUE klass;
2679 object:
2680 klass = CLASS_OF(obj);
2681 if (RB_TYPE_P(klass, T_CLASS) && RCLASS_SINGLETON_P(klass)) {
2682 s = FAKE_CSTR(&s_str, "");
2683 if (obj == rb_vm_top_self()) {
2684 c = FAKE_CSTR(&c_str, "main");
2685 }
2686 else {
2687 c = rb_any_to_s(obj);
2688 }
2689 break;
2690 }
2691 else {
2692 s = FAKE_CSTR(&s_str, "an instance of ");
2693 c = rb_class_real(klass);
2694 }
2695 }
2696 c2 = rb_protect(name_err_mesg_receiver_name, c, &state);
2697 if (state || NIL_OR_UNDEF_P(c2))
2698 c2 = rb_protect(rb_inspect, c, &state);
2699 if (state) {
2700 rb_set_errinfo(Qnil);
2701 }
2702 c2 = rb_check_string_type(c2);
2703 if (NIL_P(c2)) {
2704 c2 = rb_any_to_s(c);
2705 }
2706 c = c2;
2707 break;
2708 }
2709 args[0] = rb_obj_as_string(ptr->name);
2710 args[1] = d;
2711 args[2] = s;
2712 args[3] = c;
2713 mesg = rb_str_format(4, args, mesg);
2714 }
2715 return mesg;
2716 }
2717
2718 /* :nodoc: */
2719 static VALUE
2720 name_err_mesg_dump(VALUE obj, VALUE limit)
2721 {
2722 return name_err_mesg_to_str(obj);
2723 }
2724
2725 /* :nodoc: */
2726 static VALUE
2727 name_err_mesg_load(VALUE klass, VALUE str)
2728 {
2729 return str;
2730 }
2731
2732 /*
2733 * call-seq:
2734 * name_error.receiver -> object
2735 *
2736 * Return the receiver associated with this NameError exception.
2737 */
2738
2739 static VALUE
2740 name_err_receiver(VALUE self)
2741 {
2742 VALUE recv = rb_ivar_lookup(self, id_recv, Qundef);
2743 if (!UNDEF_P(recv)) return recv;
2744
2745 VALUE mesg = rb_attr_get(self, id_mesg);
2746 if (!rb_typeddata_is_kind_of(mesg, &name_err_mesg_data_type)) {
2747 rb_raise(rb_eArgError, "no receiver is available");
2748 }
2749
2750 name_error_message_t *ptr;
2751 TypedData_Get_Struct(mesg, name_error_message_t, &name_err_mesg_data_type, ptr);
2752 return ptr->recv;
2753 }
2754
2755 /*
2756 * call-seq:
2757 * no_method_error.args -> obj
2758 *
2759 * Return the arguments passed in as the third parameter to
2760 * the constructor.
2761 */
2762
2763 static VALUE
2764 nometh_err_args(VALUE self)
2765 {
2766 return rb_attr_get(self, id_args);
2767 }
2768
2769 /*
2770 * call-seq:
2771 * no_method_error.private_call? -> true or false
2772 *
2773 * Return true if the caused method was called as private.
2774 */
2775
2776 static VALUE
2777 nometh_err_private_call_p(VALUE self)
2778 {
2779 return rb_attr_get(self, id_private_call_p);
2780 }
2781
2782 void
2783 rb_invalid_str(const char *str, const char *type)
2784 {
2785 VALUE s = rb_str_new2(str);
2786
2787 rb_raise(rb_eArgError, "invalid value for %s: %+"PRIsVALUE, type, s);
2788 }
2789
2790 /*
2791 * call-seq:
2792 * key_error.receiver -> object
2793 *
2794 * Return the receiver associated with this KeyError exception.
2795 */
2796
2797 static VALUE
2798 key_err_receiver(VALUE self)
2799 {
2800 VALUE recv;
2801
2802 recv = rb_ivar_lookup(self, id_receiver, Qundef);
2803 if (!UNDEF_P(recv)) return recv;
2804 rb_raise(rb_eArgError, "no receiver is available");
2805 }
2806
2807 /*
2808 * call-seq:
2809 * key_error.key -> object
2810 *
2811 * Return the key caused this KeyError exception.
2812 */
2813
2814 static VALUE
2815 key_err_key(VALUE self)
2816 {
2817 VALUE key;
2818
2819 key = rb_ivar_lookup(self, id_key, Qundef);
2820 if (!UNDEF_P(key)) return key;
2821 rb_raise(rb_eArgError, "no key is available");
2822 }
2823
2824 VALUE
2825 rb_key_err_new(VALUE mesg, VALUE recv, VALUE key)
2826 {
2827 VALUE exc = rb_obj_alloc(rb_eKeyError);
2828 rb_ivar_set(exc, id_mesg, mesg);
2829 rb_ivar_set(exc, id_bt, Qnil);
2830 rb_ivar_set(exc, id_key, key);
2831 rb_ivar_set(exc, id_receiver, recv);
2832 return exc;
2833 }
2834
2835 /*
2836 * call-seq:
2837 * KeyError.new(message=nil, receiver: nil, key: nil) -> key_error
2838 *
2839 * Construct a new +KeyError+ exception with the given message,
2840 * receiver and key.
2841 */
2842
2843 static VALUE
2844 key_err_initialize(int argc, VALUE *argv, VALUE self)
2845 {
2846 VALUE options;
2847
2848 rb_call_super(rb_scan_args(argc, argv, "01:", NULL, &options), argv);
2849
2850 if (!NIL_P(options)) {
2851 ID keywords[2];
2852 VALUE values[numberof(keywords)];
2853 int i;
2854 keywords[0] = id_receiver;
2855 keywords[1] = id_key;
2856 rb_get_kwargs(options, keywords, 0, numberof(values), values);
2857 for (i = 0; i < numberof(values); ++i) {
2858 if (!UNDEF_P(values[i])) {
2859 rb_ivar_set(self, keywords[i], values[i]);
2860 }
2861 }
2862 }
2863
2864 return self;
2865 }
2866
2867 /*
2868 * call-seq:
2869 * no_matching_pattern_key_error.matchee -> object
2870 *
2871 * Return the matchee associated with this NoMatchingPatternKeyError exception.
2872 */
2873
2874 static VALUE
2875 no_matching_pattern_key_err_matchee(VALUE self)
2876 {
2877 VALUE matchee;
2878
2879 matchee = rb_ivar_lookup(self, id_matchee, Qundef);
2880 if (!UNDEF_P(matchee)) return matchee;
2881 rb_raise(rb_eArgError, "no matchee is available");
2882 }
2883
2884 /*
2885 * call-seq:
2886 * no_matching_pattern_key_error.key -> object
2887 *
2888 * Return the key caused this NoMatchingPatternKeyError exception.
2889 */
2890
2891 static VALUE
2892 no_matching_pattern_key_err_key(VALUE self)
2893 {
2894 VALUE key;
2895
2896 key = rb_ivar_lookup(self, id_key, Qundef);
2897 if (!UNDEF_P(key)) return key;
2898 rb_raise(rb_eArgError, "no key is available");
2899 }
2900
2901 /*
2902 * call-seq:
2903 * NoMatchingPatternKeyError.new(message=nil, matchee: nil, key: nil) -> no_matching_pattern_key_error
2904 *
2905 * Construct a new +NoMatchingPatternKeyError+ exception with the given message,
2906 * matchee and key.
2907 */
2908
2909 static VALUE
2910 no_matching_pattern_key_err_initialize(int argc, VALUE *argv, VALUE self)
2911 {
2912 VALUE options;
2913
2914 rb_call_super(rb_scan_args(argc, argv, "01:", NULL, &options), argv);
2915
2916 if (!NIL_P(options)) {
2917 ID keywords[2];
2918 VALUE values[numberof(keywords)];
2919 int i;
2920 keywords[0] = id_matchee;
2921 keywords[1] = id_key;
2922 rb_get_kwargs(options, keywords, 0, numberof(values), values);
2923 for (i = 0; i < numberof(values); ++i) {
2924 if (!UNDEF_P(values[i])) {
2925 rb_ivar_set(self, keywords[i], values[i]);
2926 }
2927 }
2928 }
2929
2930 return self;
2931 }
2932
2933
2934 /*
2935 * call-seq:
2936 * SyntaxError.new([msg]) -> syntax_error
2937 *
2938 * Construct a SyntaxError exception.
2939 */
2940
2941 static VALUE
2942 syntax_error_initialize(int argc, VALUE *argv, VALUE self)
2943 {
2944 VALUE mesg;
2945 if (argc == 0) {
2946 mesg = rb_fstring_lit("compile error");
2947 argc = 1;
2948 argv = &mesg;
2949 }
2950 return rb_call_super(argc, argv);
2951 }
2952
2953 static VALUE
2954 syntax_error_with_path(VALUE exc, VALUE path, VALUE *mesg, rb_encoding *enc)
2955 {
2956 if (NIL_P(exc)) {
2957 *mesg = rb_enc_str_new(0, 0, enc);
2958 exc = rb_class_new_instance(1, mesg, rb_eSyntaxError);
2959 rb_ivar_set(exc, id_i_path, path);
2960 }
2961 else {
2962 VALUE old_path = rb_attr_get(exc, id_i_path);
2963 if (old_path != path) {
2964 if (rb_str_equal(path, old_path)) {
2965 rb_raise(rb_eArgError, "SyntaxError#path changed: %+"PRIsVALUE" (%p->%p)",
2966 old_path, (void *)old_path, (void *)path);
2967 }
2968 else {
2969 rb_raise(rb_eArgError, "SyntaxError#path changed: %+"PRIsVALUE"(%s%s)->%+"PRIsVALUE"(%s)",
2970 old_path, rb_enc_name(rb_enc_get(old_path)),
2971 (FL_TEST(old_path, RSTRING_FSTR) ? ":FSTR" : ""),
2972 path, rb_enc_name(rb_enc_get(path)));
2973 }
2974 }
2975 VALUE s = *mesg = rb_attr_get(exc, idMesg);
2976 if (RSTRING_LEN(s) > 0 && *(RSTRING_END(s)-1) != '\n')
2977 rb_str_cat_cstr(s, "\n");
2978 }
2979 return exc;
2980 }
2981
2982 /*
2983 * Document-module: Errno
2984 *
2985 * When an operating system encounters an error,
2986 * it typically reports the error as an integer error code:
2987 *
2988 * $ ls nosuch.txt
2989 * ls: cannot access 'nosuch.txt': No such file or directory
2990 * $ echo $? # Code for last error.
2991 * 2
2992 *
2993 * When the Ruby interpreter interacts with the operating system
2994 * and receives such an error code (e.g., +2+),
2995 * it maps the code to a particular Ruby exception class (e.g., +Errno::ENOENT+):
2996 *
2997 * File.open('nosuch.txt')
2998 * # => No such file or directory @ rb_sysopen - nosuch.txt (Errno::ENOENT)
2999 *
3000 * Each such class is:
3001 *
3002 * - A nested class in this module, +Errno+.
3003 * - A subclass of class SystemCallError.
3004 * - Associated with an error code.
3005 *
3006 * Thus:
3007 *
3008 * Errno::ENOENT.superclass # => SystemCallError
3009 * Errno::ENOENT::Errno # => 2
3010 *
3011 * The names of nested classes are returned by method +Errno.constants+:
3012 *
3013 * Errno.constants.size # => 158
3014 * Errno.constants.sort.take(5) # => [:E2BIG, :EACCES, :EADDRINUSE, :EADDRNOTAVAIL, :EADV]
3015 *
3016 * As seen above, the error code associated with each class
3017 * is available as the value of a constant;
3018 * the value for a particular class may vary among operating systems.
3019 * If the class is not needed for the particular operating system,
3020 * the value is zero:
3021 *
3022 * Errno::ENOENT::Errno # => 2
3023 * Errno::ENOTCAPABLE::Errno # => 0
3024 *
3025 * Each class in Errno can be created with optional messages:
3026 *
3027 * Errno::EPIPE.new # => #<Errno::EPIPE: Broken pipe>
3028 * Errno::EPIPE.new("foo") # => #<Errno::EPIPE: Broken pipe - foo>
3029 * Errno::EPIPE.new("foo", "here") # => #<Errno::EPIPE: Broken pipe @ here - foo>
3030 *
3031 * See SystemCallError.new.
3032 */
3033
3034 static st_table *syserr_tbl;
3035
3036 void
3037 rb_free_warning(void)
3038 {
3039 st_free_table(warning_categories.id2enum);
3040 st_free_table(warning_categories.enum2id);
3041 st_free_table(syserr_tbl);
3042 }
3043
3044 static VALUE
3045 setup_syserr(int n, const char *name)
3046 {
3047 VALUE error = rb_define_class_under(rb_mErrno, name, rb_eSystemCallError);
3048
3049 /* capture nonblock errnos for WaitReadable/WaitWritable subclasses */
3050 switch (n) {
3051 case EAGAIN:
3052 rb_eEAGAIN = error;
3053
3054 #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
3055 break;
3056 case EWOULDBLOCK:
3057 #endif
3058
3059 rb_eEWOULDBLOCK = error;
3060 break;
3061 case EINPROGRESS:
3062 rb_eEINPROGRESS = error;
3063 break;
3064 }
3065
3066 rb_define_const(error, "Errno", INT2NUM(n));
3067 st_add_direct(syserr_tbl, n, (st_data_t)error);
3068 return error;
3069 }
3070
3071 static VALUE
3072 set_syserr(int n, const char *name)
3073 {
3074 st_data_t error;
3075
3076 if (!st_lookup(syserr_tbl, n, &error)) {
3077 return setup_syserr(n, name);
3078 }
3079 else {
3080 VALUE errclass = (VALUE)error;
3081 rb_define_const(rb_mErrno, name, errclass);
3082 return errclass;
3083 }
3084 }
3085
3086 static VALUE
3087 get_syserr(int n)
3088 {
3089 st_data_t error;
3090
3091 if (!st_lookup(syserr_tbl, n, &error)) {
3092 char name[DECIMAL_SIZE_OF(n) + sizeof("E-")];
3093
3094 snprintf(name, sizeof(name), "E%03d", n);
3095 return setup_syserr(n, name);
3096 }
3097 return (VALUE)error;
3098 }
3099
3100 /*
3101 * call-seq:
3102 * SystemCallError.new(msg, errno = nil, func = nil) -> system_call_error_subclass
3103 *
3104 * If _errno_ corresponds to a known system error code, constructs the
3105 * appropriate Errno class for that error, otherwise constructs a
3106 * generic SystemCallError object. The error number is subsequently
3107 * available via the #errno method.
3108 *
3109 * If only numeric object is given, it is treated as an Integer _errno_,
3110 * and _msg_ is omitted, otherwise the first argument _msg_ is used as
3111 * the additional error message.
3112 *
3113 * SystemCallError.new(Errno::EPIPE::Errno)
3114 * #=> #<Errno::EPIPE: Broken pipe>
3115 *
3116 * SystemCallError.new("foo")
3117 * #=> #<SystemCallError: unknown error - foo>
3118 *
3119 * SystemCallError.new("foo", Errno::EPIPE::Errno)
3120 * #=> #<Errno::EPIPE: Broken pipe - foo>
3121 *
3122 * If _func_ is not +nil+, it is appended to the message with "<tt> @ </tt>".
3123 *
3124 * SystemCallError.new("foo", Errno::EPIPE::Errno, "here")
3125 * #=> #<Errno::EPIPE: Broken pipe @ here - foo>
3126 *
3127 * A subclass of SystemCallError can also be instantiated via the
3128 * +new+ method of the subclass. See Errno.
3129 */
3130
3131 static VALUE
3132 syserr_initialize(int argc, VALUE *argv, VALUE self)
3133 {
3134 const char *err;
3135 VALUE mesg, error, func, errmsg;
3136 VALUE klass = rb_obj_class(self);
3137
3138 if (klass == rb_eSystemCallError) {
3139 st_data_t data = (st_data_t)klass;
3140 rb_scan_args(argc, argv, "12", &mesg, &error, &func);
3141 if (argc == 1 && FIXNUM_P(mesg)) {
3142 error = mesg; mesg = Qnil;
3143 }
3144 if (!NIL_P(error) && st_lookup(syserr_tbl, NUM2LONG(error), &data)) {
3145 klass = (VALUE)data;
3146 /* change class */
3147 if (!RB_TYPE_P(self, T_OBJECT)) { /* insurance to avoid type crash */
3148 rb_raise(rb_eTypeError, "invalid instance type");
3149 }
3150 RBASIC_SET_CLASS(self, klass);
3151 }
3152 }
3153 else {
3154 rb_scan_args(argc, argv, "02", &mesg, &func);
3155 error = rb_const_get(klass, id_Errno);
3156 }
3157 if (!NIL_P(error)) err = strerror(NUM2INT(error));
3158 else err = "unknown error";
3159
3160 errmsg = rb_enc_str_new_cstr(err, rb_locale_encoding());
3161 if (!NIL_P(mesg)) {
3162 VALUE str = StringValue(mesg);
3163
3164 if (!NIL_P(func)) rb_str_catf(errmsg, " @ %"PRIsVALUE, func);
3165 rb_str_catf(errmsg, " - %"PRIsVALUE, str);
3166 }
3167 mesg = errmsg;
3168
3169 rb_call_super(1, &mesg);
3170 rb_ivar_set(self, id_errno, error);
3171 return self;
3172 }
3173
3174 /*
3175 * call-seq:
3176 * system_call_error.errno -> integer
3177 *
3178 * Return this SystemCallError's error number.
3179 */
3180
3181 static VALUE
3182 syserr_errno(VALUE self)
3183 {
3184 return rb_attr_get(self, id_errno);
3185 }
3186
3187 /*
3188 * call-seq:
3189 * system_call_error === other -> true or false
3190 *
3191 * Return +true+ if the receiver is a generic +SystemCallError+, or
3192 * if the error numbers +self+ and _other_ are the same.
3193 */
3194
3195 static VALUE
3196 syserr_eqq(VALUE self, VALUE exc)
3197 {
3198 VALUE num, e;
3199
3200 if (!rb_obj_is_kind_of(exc, rb_eSystemCallError)) {
3201 if (!rb_respond_to(exc, id_errno)) return Qfalse;
3202 }
3203 else if (self == rb_eSystemCallError) return Qtrue;
3204
3205 num = rb_attr_get(exc, id_errno);
3206 if (NIL_P(num)) {
3207 num = rb_funcallv(exc, id_errno, 0, 0);
3208 }
3209 e = rb_const_get(self, id_Errno);
3210 return RBOOL(FIXNUM_P(num) ? num == e : rb_equal(num, e));
3211 }
3212
3213
3214 /*
3215 * Document-class: StandardError
3216 *
3217 * The most standard error types are subclasses of StandardError. A
3218 * rescue clause without an explicit Exception class will rescue all
3219 * StandardErrors (and only those).
3220 *
3221 * def foo
3222 * raise "Oups"
3223 * end
3224 * foo rescue "Hello" #=> "Hello"
3225 *
3226 * On the other hand:
3227 *
3228 * require 'does/not/exist' rescue "Hi"
3229 *
3230 * <em>raises the exception:</em>
3231 *
3232 * LoadError: no such file to load -- does/not/exist
3233 *
3234 */
3235
3236 /*
3237 * Document-class: SystemExit
3238 *
3239 * Raised by +exit+ to initiate the termination of the script.
3240 */
3241
3242 /*
3243 * Document-class: SignalException
3244 *
3245 * Raised when a signal is received.
3246 *
3247 * begin
3248 * Process.kill('HUP',Process.pid)
3249 * sleep # wait for receiver to handle signal sent by Process.kill
3250 * rescue SignalException => e
3251 * puts "received Exception #{e}"
3252 * end
3253 *
3254 * <em>produces:</em>
3255 *
3256 * received Exception SIGHUP
3257 */
3258
3259 /*
3260 * Document-class: Interrupt
3261 *
3262 * Raised when the interrupt signal is received, typically because the
3263 * user has pressed Control-C (on most posix platforms). As such, it is a
3264 * subclass of +SignalException+.
3265 *
3266 * begin
3267 * puts "Press ctrl-C when you get bored"
3268 * loop {}
3269 * rescue Interrupt => e
3270 * puts "Note: You will typically use Signal.trap instead."
3271 * end
3272 *
3273 * <em>produces:</em>
3274 *
3275 * Press ctrl-C when you get bored
3276 *
3277 * <em>then waits until it is interrupted with Control-C and then prints:</em>
3278 *
3279 * Note: You will typically use Signal.trap instead.
3280 */
3281
3282 /*
3283 * Document-class: TypeError
3284 *
3285 * Raised when encountering an object that is not of the expected type.
3286 *
3287 * [1, 2, 3].first("two")
3288 *
3289 * <em>raises the exception:</em>
3290 *
3291 * TypeError: no implicit conversion of String into Integer
3292 *
3293 */
3294
3295 /*
3296 * Document-class: ArgumentError
3297 *
3298 * Raised when the arguments are wrong and there isn't a more specific
3299 * Exception class.
3300 *
3301 * Ex: passing the wrong number of arguments
3302 *
3303 * [1, 2, 3].first(4, 5)
3304 *
3305 * <em>raises the exception:</em>
3306 *
3307 * ArgumentError: wrong number of arguments (given 2, expected 1)
3308 *
3309 * Ex: passing an argument that is not acceptable:
3310 *
3311 * [1, 2, 3].first(-4)
3312 *
3313 * <em>raises the exception:</em>
3314 *
3315 * ArgumentError: negative array size
3316 */
3317
3318 /*
3319 * Document-class: IndexError
3320 *
3321 * Raised when the given index is invalid.
3322 *
3323 * a = [:foo, :bar]
3324 * a.fetch(0) #=> :foo
3325 * a[4] #=> nil
3326 * a.fetch(4) #=> IndexError: index 4 outside of array bounds: -2...2
3327 *
3328 */
3329
3330 /*
3331 * Document-class: KeyError
3332 *
3333 * Raised when the specified key is not found. It is a subclass of
3334 * IndexError.
3335 *
3336 * h = {"foo" => :bar}
3337 * h.fetch("foo") #=> :bar
3338 * h.fetch("baz") #=> KeyError: key not found: "baz"
3339 *
3340 */
3341
3342 /*
3343 * Document-class: RangeError
3344 *
3345 * Raised when a given numerical value is out of range.
3346 *
3347 * [1, 2, 3].drop(1 << 100)
3348 *
3349 * <em>raises the exception:</em>
3350 *
3351 * RangeError: bignum too big to convert into `long'
3352 */
3353
3354 /*
3355 * Document-class: ScriptError
3356 *
3357 * ScriptError is the superclass for errors raised when a script
3358 * can not be executed because of a +LoadError+,
3359 * +NotImplementedError+ or a +SyntaxError+. Note these type of
3360 * +ScriptErrors+ are not +StandardError+ and will not be
3361 * rescued unless it is specified explicitly (or its ancestor
3362 * +Exception+).
3363 */
3364
3365 /*
3366 * Document-class: SyntaxError
3367 *
3368 * Raised when encountering Ruby code with an invalid syntax.
3369 *
3370 * eval("1+1=2")
3371 *
3372 * <em>raises the exception:</em>
3373 *
3374 * SyntaxError: (eval):1: syntax error, unexpected '=', expecting $end
3375 */
3376
3377 /*
3378 * Document-class: LoadError
3379 *
3380 * Raised when a file required (a Ruby script, extension library, ...)
3381 * fails to load.
3382 *
3383 * require 'this/file/does/not/exist'
3384 *
3385 * <em>raises the exception:</em>
3386 *
3387 * LoadError: no such file to load -- this/file/does/not/exist
3388 */
3389
3390 /*
3391 * Document-class: NotImplementedError
3392 *
3393 * Raised when a feature is not implemented on the current platform. For
3394 * example, methods depending on the +fsync+ or +fork+ system calls may
3395 * raise this exception if the underlying operating system or Ruby
3396 * runtime does not support them.
3397 *
3398 * Note that if +fork+ raises a +NotImplementedError+, then
3399 * <code>respond_to?(:fork)</code> returns +false+.
3400 */
3401
3402 /*
3403 * Document-class: NameError
3404 *
3405 * Raised when a given name is invalid or undefined.
3406 *
3407 * puts foo
3408 *
3409 * <em>raises the exception:</em>
3410 *
3411 * NameError: undefined local variable or method `foo' for main:Object
3412 *
3413 * Since constant names must start with a capital:
3414 *
3415 * Integer.const_set :answer, 42
3416 *
3417 * <em>raises the exception:</em>
3418 *
3419 * NameError: wrong constant name answer
3420 */
3421
3422 /*
3423 * Document-class: NoMethodError
3424 *
3425 * Raised when a method is called on a receiver which doesn't have it
3426 * defined and also fails to respond with +method_missing+.
3427 *
3428 * "hello".to_ary
3429 *
3430 * <em>raises the exception:</em>
3431 *
3432 * NoMethodError: undefined method `to_ary' for an instance of String
3433 */
3434
3435 /*
3436 * Document-class: FrozenError
3437 *
3438 * Raised when there is an attempt to modify a frozen object.
3439 *
3440 * [1, 2, 3].freeze << 4
3441 *
3442 * <em>raises the exception:</em>
3443 *
3444 * FrozenError: can't modify frozen Array
3445 */
3446
3447 /*
3448 * Document-class: RuntimeError
3449 *
3450 * A generic error class raised when an invalid operation is attempted.
3451 * Kernel#raise will raise a RuntimeError if no Exception class is
3452 * specified.
3453 *
3454 * raise "ouch"
3455 *
3456 * <em>raises the exception:</em>
3457 *
3458 * RuntimeError: ouch
3459 */
3460
3461 /*
3462 * Document-class: SecurityError
3463 *
3464 * No longer used by internal code.
3465 */
3466
3467 /*
3468 * Document-class: NoMemoryError
3469 *
3470 * Raised when memory allocation fails.
3471 */
3472
3473 /*
3474 * Document-class: SystemCallError
3475 *
3476 * SystemCallError is the base class for all low-level
3477 * platform-dependent errors.
3478 *
3479 * The errors available on the current platform are subclasses of
3480 * SystemCallError and are defined in the Errno module.
3481 *
3482 * File.open("does/not/exist")
3483 *
3484 * <em>raises the exception:</em>
3485 *
3486 * Errno::ENOENT: No such file or directory - does/not/exist
3487 */
3488
3489 /*
3490 * Document-class: EncodingError
3491 *
3492 * EncodingError is the base class for encoding errors.
3493 */
3494
3495 /*
3496 * Document-class: Encoding::CompatibilityError
3497 *
3498 * Raised by Encoding and String methods when the source encoding is
3499 * incompatible with the target encoding.
3500 */
3501
3502 /*
3503 * Document-class: fatal
3504 *
3505 * +fatal+ is an Exception that is raised when Ruby has encountered a fatal
3506 * error and must exit.
3507 */
3508
3509 /*
3510 * Document-class: NameError::message
3511 * :nodoc:
3512 */
3513
3514 /*
3515 * Document-class: Exception
3516 *
3517 * Class +Exception+ and its subclasses are used to indicate that an error
3518 * or other problem has occurred,
3519 * and may need to be handled.
3520 * See {Exceptions}[rdoc-ref:exceptions.md].
3521 *
3522 * An +Exception+ object carries certain information:
3523 *
3524 * - The type (the exception's class),
3525 * commonly StandardError, RuntimeError, or a subclass of one or the other;
3526 * see {Built-In Exception Class Hierarchy}[rdoc-ref:Exception@Built-In+Exception+Class+Hierarchy].
3527 * - An optional descriptive message;
3528 * see methods ::new, #message.
3529 * - Optional backtrace information;
3530 * see methods #backtrace, #backtrace_locations, #set_backtrace.
3531 * - An optional cause;
3532 * see method #cause.
3533 *
3534 * == Built-In \Exception Class Hierarchy
3535 *
3536 * The hierarchy of built-in subclasses of class +Exception+:
3537 *
3538 * * NoMemoryError
3539 * * ScriptError
3540 * * LoadError
3541 * * NotImplementedError
3542 * * SyntaxError
3543 * * SecurityError
3544 * * SignalException
3545 * * Interrupt
3546 * * StandardError
3547 * * ArgumentError
3548 * * UncaughtThrowError
3549 * * EncodingError
3550 * * FiberError
3551 * * IOError
3552 * * EOFError
3553 * * IndexError
3554 * * KeyError
3555 * * StopIteration
3556 * * ClosedQueueError
3557 * * LocalJumpError
3558 * * NameError
3559 * * NoMethodError
3560 * * RangeError
3561 * * FloatDomainError
3562 * * RegexpError
3563 * * RuntimeError
3564 * * FrozenError
3565 * * SystemCallError
3566 * * Errno (and its subclasses, representing system errors)
3567 * * ThreadError
3568 * * TypeError
3569 * * ZeroDivisionError
3570 * * SystemExit
3571 * * SystemStackError
3572 * * {fatal}[rdoc-ref:fatal]
3573 *
3574 */
3575
3576 static VALUE
3577 exception_alloc(VALUE klass)
3578 {
3579 return rb_class_allocate_instance(klass);
3580 }
3581
3582 static VALUE
3583 exception_dumper(VALUE exc)
3584 {
3585 // TODO: Currently, the instance variables "bt" and "bt_locations"
3586 // refers to the same object (Array of String). But "bt_locations"
3587 // should have an Array of Thread::Backtrace::Locations.
3588
3589 return exc;
3590 }
3591
3592 static int
3593 ivar_copy_i(ID key, VALUE val, st_data_t exc)
3594 {
3595 rb_ivar_set((VALUE)exc, key, val);
3596 return ST_CONTINUE;
3597 }
3598
3599 void rb_exc_check_circular_cause(VALUE exc);
3600
3601 static VALUE
3602 exception_loader(VALUE exc, VALUE obj)
3603 {
3604 // The loader function of rb_marshal_define_compat seems to be called for two events:
3605 // one is for fixup (r_fixup_compat), the other is for TYPE_USERDEF.
3606 // In the former case, the first argument is an instance of Exception (because
3607 // we pass rb_eException to rb_marshal_define_compat). In the latter case, the first
3608 // argument is a class object (see TYPE_USERDEF case in r_object0).
3609 // We want to copy all instance variables (but "bt_locations") from obj to exc.
3610 // But we do not want to do so in the second case, so the following branch is for that.
3611 if (RB_TYPE_P(exc, T_CLASS)) return obj; // maybe called from Marshal's TYPE_USERDEF
3612
3613 rb_ivar_foreach(obj, ivar_copy_i, exc);
3614
3615 rb_exc_check_circular_cause(exc);
3616
3617 if (rb_attr_get(exc, id_bt) == rb_attr_get(exc, id_bt_locations)) {
3618 rb_ivar_set(exc, id_bt_locations, Qnil);
3619 }
3620
3621 return exc;
3622 }
3623
3624 void
3625 Init_Exception(void)
3626 {
3627 rb_eException = rb_define_class("Exception", rb_cObject);
3628 rb_define_alloc_func(rb_eException, exception_alloc);
3629 rb_marshal_define_compat(rb_eException, rb_eException, exception_dumper, exception_loader);
3630 rb_define_singleton_method(rb_eException, "exception", rb_class_new_instance, -1);
3631 rb_define_singleton_method(rb_eException, "to_tty?", exc_s_to_tty_p, 0);
3632 rb_define_method(rb_eException, "exception", exc_exception, -1);
3633 rb_define_method(rb_eException, "initialize", exc_initialize, -1);
3634 rb_define_method(rb_eException, "==", exc_equal, 1);
3635 rb_define_method(rb_eException, "to_s", exc_to_s, 0);
3636 rb_define_method(rb_eException, "message", exc_message, 0);
3637 rb_define_method(rb_eException, "detailed_message", exc_detailed_message, -1);
3638 rb_define_method(rb_eException, "full_message", exc_full_message, -1);
3639 rb_define_method(rb_eException, "inspect", exc_inspect, 0);
3640 rb_define_method(rb_eException, "backtrace", exc_backtrace, 0);
3641 rb_define_method(rb_eException, "backtrace_locations", exc_backtrace_locations, 0);
3642 rb_define_method(rb_eException, "set_backtrace", exc_set_backtrace, 1);
3643 rb_define_method(rb_eException, "cause", exc_cause, 0);
3644
3645 rb_eSystemExit = rb_define_class("SystemExit", rb_eException);
3646 rb_define_method(rb_eSystemExit, "initialize", exit_initialize, -1);
3647 rb_define_method(rb_eSystemExit, "status", exit_status, 0);
3648 rb_define_method(rb_eSystemExit, "success?", exit_success_p, 0);
3649
3650 rb_eFatal = rb_define_class("fatal", rb_eException);
3651 rb_eSignal = rb_define_class("SignalException", rb_eException);
3652 rb_eInterrupt = rb_define_class("Interrupt", rb_eSignal);
3653
3654 rb_eStandardError = rb_define_class("StandardError", rb_eException);
3655 rb_eTypeError = rb_define_class("TypeError", rb_eStandardError);
3656 rb_eArgError = rb_define_class("ArgumentError", rb_eStandardError);
3657 rb_eIndexError = rb_define_class("IndexError", rb_eStandardError);
3658 rb_eKeyError = rb_define_class("KeyError", rb_eIndexError);
3659 rb_define_method(rb_eKeyError, "initialize", key_err_initialize, -1);
3660 rb_define_method(rb_eKeyError, "receiver", key_err_receiver, 0);
3661 rb_define_method(rb_eKeyError, "key", key_err_key, 0);
3662 rb_eRangeError = rb_define_class("RangeError", rb_eStandardError);
3663
3664 rb_eScriptError = rb_define_class("ScriptError", rb_eException);
3665 rb_eSyntaxError = rb_define_class("SyntaxError", rb_eScriptError);
3666 rb_define_method(rb_eSyntaxError, "initialize", syntax_error_initialize, -1);
3667
3668 /* RDoc will use literal name value while parsing rb_attr,
3669 * and will render `idPath` as an attribute name without this trick */
3670 ID path = idPath;
3671
3672 /* the path that failed to parse */
3673 rb_attr(rb_eSyntaxError, path, TRUE, FALSE, FALSE);
3674
3675 rb_eLoadError = rb_define_class("LoadError", rb_eScriptError);
3676 /* the path that failed to load */
3677 rb_attr(rb_eLoadError, path, TRUE, FALSE, FALSE);
3678
3679 rb_eNotImpError = rb_define_class("NotImplementedError", rb_eScriptError);
3680
3681 rb_eNameError = rb_define_class("NameError", rb_eStandardError);
3682 rb_define_method(rb_eNameError, "initialize", name_err_initialize, -1);
3683 rb_define_method(rb_eNameError, "name", name_err_name, 0);
3684 rb_define_method(rb_eNameError, "receiver", name_err_receiver, 0);
3685 rb_define_method(rb_eNameError, "local_variables", name_err_local_variables, 0);
3686 rb_cNameErrorMesg = rb_define_class_under(rb_eNameError, "message", rb_cObject);
3687 rb_define_alloc_func(rb_cNameErrorMesg, name_err_mesg_alloc);
3688 rb_define_method(rb_cNameErrorMesg, "initialize_copy", name_err_mesg_init_copy, 1);
3689 rb_define_method(rb_cNameErrorMesg, "==", name_err_mesg_equal, 1);
3690 rb_define_method(rb_cNameErrorMesg, "to_str", name_err_mesg_to_str, 0);
3691 rb_define_method(rb_cNameErrorMesg, "_dump", name_err_mesg_dump, 1);
3692 rb_define_singleton_method(rb_cNameErrorMesg, "_load", name_err_mesg_load, 1);
3693 rb_eNoMethodError = rb_define_class("NoMethodError", rb_eNameError);
3694 rb_define_method(rb_eNoMethodError, "initialize", nometh_err_initialize, -1);
3695 rb_define_method(rb_eNoMethodError, "args", nometh_err_args, 0);
3696 rb_define_method(rb_eNoMethodError, "private_call?", nometh_err_private_call_p, 0);
3697
3698 rb_eRuntimeError = rb_define_class("RuntimeError", rb_eStandardError);
3699 rb_eFrozenError = rb_define_class("FrozenError", rb_eRuntimeError);
3700 rb_define_method(rb_eFrozenError, "initialize", frozen_err_initialize, -1);
3701 rb_define_method(rb_eFrozenError, "receiver", frozen_err_receiver, 0);
3702 rb_eSecurityError = rb_define_class("SecurityError", rb_eException);
3703 rb_eNoMemError = rb_define_class("NoMemoryError", rb_eException);
3704 rb_eEncodingError = rb_define_class("EncodingError", rb_eStandardError);
3705 rb_eEncCompatError = rb_define_class_under(rb_cEncoding, "CompatibilityError", rb_eEncodingError);
3706 rb_eNoMatchingPatternError = rb_define_class("NoMatchingPatternError", rb_eStandardError);
3707 rb_eNoMatchingPatternKeyError = rb_define_class("NoMatchingPatternKeyError", rb_eNoMatchingPatternError);
3708 rb_define_method(rb_eNoMatchingPatternKeyError, "initialize", no_matching_pattern_key_err_initialize, -1);
3709 rb_define_method(rb_eNoMatchingPatternKeyError, "matchee", no_matching_pattern_key_err_matchee, 0);
3710 rb_define_method(rb_eNoMatchingPatternKeyError, "key", no_matching_pattern_key_err_key, 0);
3711
3712 syserr_tbl = st_init_numtable();
3713 rb_eSystemCallError = rb_define_class("SystemCallError", rb_eStandardError);
3714 rb_define_method(rb_eSystemCallError, "initialize", syserr_initialize, -1);
3715 rb_define_method(rb_eSystemCallError, "errno", syserr_errno, 0);
3716 rb_define_singleton_method(rb_eSystemCallError, "===", syserr_eqq, 1);
3717
3718 rb_mErrno = rb_define_module("Errno");
3719
3720 rb_mWarning = rb_define_module("Warning");
3721 rb_define_singleton_method(rb_mWarning, "[]", rb_warning_s_aref, 1);
3722 rb_define_singleton_method(rb_mWarning, "[]=", rb_warning_s_aset, 2);
3723 rb_define_singleton_method(rb_mWarning, "categories", rb_warning_s_categories, 0);
3724 rb_define_method(rb_mWarning, "warn", rb_warning_s_warn, -1);
3725 rb_extend_object(rb_mWarning, rb_mWarning);
3726
3727 /* :nodoc: */
3728 rb_cWarningBuffer = rb_define_class_under(rb_mWarning, "buffer", rb_cString);
3729 rb_define_method(rb_cWarningBuffer, "write", warning_write, -1);
3730
3731 id_cause = rb_intern_const("cause");
3732 id_message = rb_intern_const("message");
3733 id_detailed_message = rb_intern_const("detailed_message");
3734 id_backtrace = rb_intern_const("backtrace");
3735 id_key = rb_intern_const("key");
3736 id_matchee = rb_intern_const("matchee");
3737 id_args = rb_intern_const("args");
3738 id_receiver = rb_intern_const("receiver");
3739 id_private_call_p = rb_intern_const("private_call?");
3740 id_local_variables = rb_intern_const("local_variables");
3741 id_Errno = rb_intern_const("Errno");
3742 id_errno = rb_intern_const("errno");
3743 id_i_path = rb_intern_const("@path");
3744 id_warn = rb_intern_const("warn");
3745 id_category = rb_intern_const("category");
3746 id_deprecated = rb_intern_const("deprecated");
3747 id_experimental = rb_intern_const("experimental");
3748 id_performance = rb_intern_const("performance");
3749 id_strict_unused_block = rb_intern_const("strict_unused_block");
3750 id_top = rb_intern_const("top");
3751 id_bottom = rb_intern_const("bottom");
3752 id_iseq = rb_make_internal_id();
3753 id_recv = rb_make_internal_id();
3754
3755 sym_category = ID2SYM(id_category);
3756 sym_highlight = ID2SYM(rb_intern_const("highlight"));
3757
3758 warning_categories.id2enum = rb_init_identtable();
3759 st_add_direct(warning_categories.id2enum, id_deprecated, RB_WARN_CATEGORY_DEPRECATED);
3760 st_add_direct(warning_categories.id2enum, id_experimental, RB_WARN_CATEGORY_EXPERIMENTAL);
3761 st_add_direct(warning_categories.id2enum, id_performance, RB_WARN_CATEGORY_PERFORMANCE);
3762 st_add_direct(warning_categories.id2enum, id_strict_unused_block, RB_WARN_CATEGORY_STRICT_UNUSED_BLOCK);
3763
3764 warning_categories.enum2id = rb_init_identtable();
3765 st_add_direct(warning_categories.enum2id, RB_WARN_CATEGORY_NONE, 0);
3766 st_add_direct(warning_categories.enum2id, RB_WARN_CATEGORY_DEPRECATED, id_deprecated);
3767 st_add_direct(warning_categories.enum2id, RB_WARN_CATEGORY_EXPERIMENTAL, id_experimental);
3768 st_add_direct(warning_categories.enum2id, RB_WARN_CATEGORY_PERFORMANCE, id_performance);
3769 st_add_direct(warning_categories.enum2id, RB_WARN_CATEGORY_STRICT_UNUSED_BLOCK, id_strict_unused_block);
3770 }
3771
3772 void
3773 rb_enc_raise(rb_encoding *enc, VALUE exc, const char *fmt, ...)
3774 {
3775 va_list args;
3776 VALUE mesg;
3777
3778 va_start(args, fmt);
3779 mesg = rb_enc_vsprintf(enc, fmt, args);
3780 va_end(args);
3781
3782 rb_exc_raise(rb_exc_new3(exc, mesg));
3783 }
3784
3785 void
3786 rb_vraise(VALUE exc, const char *fmt, va_list ap)
3787 {
3788 rb_exc_raise(rb_exc_new3(exc, rb_vsprintf(fmt, ap)));
3789 }
3790
3791 void
3792 rb_raise(VALUE exc_class, const char *fmt, ...)
3793 {
3794 va_list args;
3795 va_start(args, fmt);
3796 VALUE exc = rb_exc_new3(exc_class, rb_vsprintf(fmt, args));
3797 va_end(args);
3798 rb_exc_raise(exc);
3799 }
3800
3801 NORETURN(static void raise_loaderror(VALUE path, VALUE mesg));
3802
3803 static void
3804 raise_loaderror(VALUE path, VALUE mesg)
3805 {
3806 VALUE err = rb_exc_new3(rb_eLoadError, mesg);
3807 rb_ivar_set(err, id_i_path, path);
3808 rb_exc_raise(err);
3809 }
3810
3811 void
3812 rb_loaderror(const char *fmt, ...)
3813 {
3814 va_list args;
3815 VALUE mesg;
3816
3817 va_start(args, fmt);
3818 mesg = rb_enc_vsprintf(rb_locale_encoding(), fmt, args);
3819 va_end(args);
3820 raise_loaderror(Qnil, mesg);
3821 }
3822
3823 void
3824 rb_loaderror_with_path(VALUE path, const char *fmt, ...)
3825 {
3826 va_list args;
3827 VALUE mesg;
3828
3829 va_start(args, fmt);
3830 mesg = rb_enc_vsprintf(rb_locale_encoding(), fmt, args);
3831 va_end(args);
3832 raise_loaderror(path, mesg);
3833 }
3834
3835 void
3836 rb_notimplement(void)
3837 {
3838 rb_raise(rb_eNotImpError,
3839 "%"PRIsVALUE"() function is unimplemented on this machine",
3840 rb_id2str(rb_frame_this_func()));
3841 }
3842
3843 void
3844 rb_fatal(const char *fmt, ...)
3845 {
3846 va_list args;
3847 VALUE mesg;
3848
3849 if (! ruby_thread_has_gvl_p()) {
3850 /* The thread has no GVL. Object allocation impossible (cant run GC),
3851 * thus no message can be printed out. */
3852 fprintf(stderr, "[FATAL] rb_fatal() outside of GVL\n");
3853 rb_print_backtrace(stderr);
3854 die();
3855 }
3856
3857 va_start(args, fmt);
3858 mesg = rb_vsprintf(fmt, args);
3859 va_end(args);
3860
3861 rb_exc_fatal(rb_exc_new3(rb_eFatal, mesg));
3862 }
3863
3864 static VALUE
3865 make_errno_exc(const char *mesg)
3866 {
3867 int n = errno;
3868
3869 errno = 0;
3870 if (n == 0) {
3871 rb_bug("rb_sys_fail(%s) - errno == 0", mesg ? mesg : "");
3872 }
3873 return rb_syserr_new(n, mesg);
3874 }
3875
3876 static VALUE
3877 make_errno_exc_str(VALUE mesg)
3878 {
3879 int n = errno;
3880
3881 errno = 0;
3882 if (!mesg) mesg = Qnil;
3883 if (n == 0) {
3884 const char *s = !NIL_P(mesg) ? RSTRING_PTR(mesg) : "";
3885 rb_bug("rb_sys_fail_str(%s) - errno == 0", s);
3886 }
3887 return rb_syserr_new_str(n, mesg);
3888 }
3889
3890 VALUE
3891 rb_syserr_new(int n, const char *mesg)
3892 {
3893 VALUE arg;
3894 arg = mesg ? rb_str_new2(mesg) : Qnil;
3895 return rb_syserr_new_str(n, arg);
3896 }
3897
3898 VALUE
3899 rb_syserr_new_str(int n, VALUE arg)
3900 {
3901 return rb_class_new_instance(1, &arg, get_syserr(n));
3902 }
3903
3904 void
3905 rb_syserr_fail(int e, const char *mesg)
3906 {
3907 rb_exc_raise(rb_syserr_new(e, mesg));
3908 }
3909
3910 void
3911 rb_syserr_fail_str(int e, VALUE mesg)
3912 {
3913 rb_exc_raise(rb_syserr_new_str(e, mesg));
3914 }
3915
3916 #undef rb_sys_fail
3917 void
3918 rb_sys_fail(const char *mesg)
3919 {
3920 rb_exc_raise(make_errno_exc(mesg));
3921 }
3922
3923 #undef rb_sys_fail_str
3924 void
3925 rb_sys_fail_str(VALUE mesg)
3926 {
3927 rb_exc_raise(make_errno_exc_str(mesg));
3928 }
3929
3930 #ifdef RUBY_FUNCTION_NAME_STRING
3931 void
3932 rb_sys_fail_path_in(const char *func_name, VALUE path)
3933 {
3934 int n = errno;
3935
3936 errno = 0;
3937 rb_syserr_fail_path_in(func_name, n, path);
3938 }
3939
3940 void
3941 rb_syserr_fail_path_in(const char *func_name, int n, VALUE path)
3942 {
3943 rb_exc_raise(rb_syserr_new_path_in(func_name, n, path));
3944 }
3945
3946 VALUE
3947 rb_syserr_new_path_in(const char *func_name, int n, VALUE path)
3948 {
3949 VALUE args[2];
3950
3951 if (!path) path = Qnil;
3952 if (n == 0) {
3953 const char *s = !NIL_P(path) ? RSTRING_PTR(path) : "";
3954 if (!func_name) func_name = "(null)";
3955 rb_bug("rb_sys_fail_path_in(%s, %s) - errno == 0",
3956 func_name, s);
3957 }
3958 args[0] = path;
3959 args[1] = rb_str_new_cstr(func_name);
3960 return rb_class_new_instance(2, args, get_syserr(n));
3961 }
3962 #endif
3963
3964 NORETURN(static void rb_mod_exc_raise(VALUE exc, VALUE mod));
3965
3966 static void
3967 rb_mod_exc_raise(VALUE exc, VALUE mod)
3968 {
3969 rb_extend_object(exc, mod);
3970 rb_exc_raise(exc);
3971 }
3972
3973 void
3974 rb_mod_sys_fail(VALUE mod, const char *mesg)
3975 {
3976 VALUE exc = make_errno_exc(mesg);
3977 rb_mod_exc_raise(exc, mod);
3978 }
3979
3980 void
3981 rb_mod_sys_fail_str(VALUE mod, VALUE mesg)
3982 {
3983 VALUE exc = make_errno_exc_str(mesg);
3984 rb_mod_exc_raise(exc, mod);
3985 }
3986
3987 void
3988 rb_mod_syserr_fail(VALUE mod, int e, const char *mesg)
3989 {
3990 VALUE exc = rb_syserr_new(e, mesg);
3991 rb_mod_exc_raise(exc, mod);
3992 }
3993
3994 void
3995 rb_mod_syserr_fail_str(VALUE mod, int e, VALUE mesg)
3996 {
3997 VALUE exc = rb_syserr_new_str(e, mesg);
3998 rb_mod_exc_raise(exc, mod);
3999 }
4000
4001 static void
4002 syserr_warning(VALUE mesg, int err)
4003 {
4004 rb_str_set_len(mesg, RSTRING_LEN(mesg)-1);
4005 rb_str_catf(mesg, ": %s\n", strerror(err));
4006 rb_write_warning_str(mesg);
4007 }
4008
4009 #if 0
4010 void
4011 rb_sys_warn(const char *fmt, ...)
4012 {
4013 if (!NIL_P(ruby_verbose)) {
4014 int errno_save = errno;
4015 with_warning_string(mesg, 0, fmt) {
4016 syserr_warning(mesg, errno_save);
4017 }
4018 errno = errno_save;
4019 }
4020 }
4021
4022 void
4023 rb_syserr_warn(int err, const char *fmt, ...)
4024 {
4025 if (!NIL_P(ruby_verbose)) {
4026 with_warning_string(mesg, 0, fmt) {
4027 syserr_warning(mesg, err);
4028 }
4029 }
4030 }
4031
4032 void
4033 rb_sys_enc_warn(rb_encoding *enc, const char *fmt, ...)
4034 {
4035 if (!NIL_P(ruby_verbose)) {
4036 int errno_save = errno;
4037 with_warning_string(mesg, enc, fmt) {
4038 syserr_warning(mesg, errno_save);
4039 }
4040 errno = errno_save;
4041 }
4042 }
4043
4044 void
4045 rb_syserr_enc_warn(int err, rb_encoding *enc, const char *fmt, ...)
4046 {
4047 if (!NIL_P(ruby_verbose)) {
4048 with_warning_string(mesg, enc, fmt) {
4049 syserr_warning(mesg, err);
4050 }
4051 }
4052 }
4053 #endif
4054
4055 void
4056 rb_sys_warning(const char *fmt, ...)
4057 {
4058 if (RTEST(ruby_verbose)) {
4059 int errno_save = errno;
4060 with_warning_string(mesg, 0, fmt) {
4061 syserr_warning(mesg, errno_save);
4062 }
4063 errno = errno_save;
4064 }
4065 }
4066
4067 #if 0
4068 void
4069 rb_syserr_warning(int err, const char *fmt, ...)
4070 {
4071 if (RTEST(ruby_verbose)) {
4072 with_warning_string(mesg, 0, fmt) {
4073 syserr_warning(mesg, err);
4074 }
4075 }
4076 }
4077 #endif
4078
4079 void
4080 rb_sys_enc_warning(rb_encoding *enc, const char *fmt, ...)
4081 {
4082 if (RTEST(ruby_verbose)) {
4083 int errno_save = errno;
4084 with_warning_string(mesg, enc, fmt) {
4085 syserr_warning(mesg, errno_save);
4086 }
4087 errno = errno_save;
4088 }
4089 }
4090
4091 void
4092 rb_syserr_enc_warning(int err, rb_encoding *enc, const char *fmt, ...)
4093 {
4094 if (RTEST(ruby_verbose)) {
4095 with_warning_string(mesg, enc, fmt) {
4096 syserr_warning(mesg, err);
4097 }
4098 }
4099 }
4100
4101 void
4102 rb_load_fail(VALUE path, const char *err)
4103 {
4104 VALUE mesg = rb_str_buf_new_cstr(err);
4105 rb_str_cat2(mesg, " -- ");
4106 rb_str_append(mesg, path); /* should be ASCII compatible */
4107 raise_loaderror(path, mesg);
4108 }
4109
4110 void
4111 rb_error_frozen(const char *what)
4112 {
4113 rb_raise(rb_eFrozenError, "can't modify frozen %s", what);
4114 }
4115
4116 void
4117 rb_frozen_error_raise(VALUE frozen_obj, const char *fmt, ...)
4118 {
4119 va_list args;
4120 VALUE exc, mesg;
4121
4122 va_start(args, fmt);
4123 mesg = rb_vsprintf(fmt, args);
4124 va_end(args);
4125 exc = rb_exc_new3(rb_eFrozenError, mesg);
4126 rb_ivar_set(exc, id_recv, frozen_obj);
4127 rb_exc_raise(exc);
4128 }
4129
4130 static VALUE
4131 inspect_frozen_obj(VALUE obj, VALUE mesg, int recur)
4132 {
4133 if (recur) {
4134 rb_str_cat_cstr(mesg, " ...");
4135 }
4136 else {
4137 rb_str_append(mesg, rb_inspect(obj));
4138 }
4139 return mesg;
4140 }
4141
4142 static VALUE
4143 get_created_info(VALUE obj, int *pline)
4144 {
4145 VALUE info = rb_attr_get(obj, id_debug_created_info);
4146
4147 if (NIL_P(info)) return Qnil;
4148
4149 VALUE path = rb_ary_entry(info, 0);
4150 VALUE line = rb_ary_entry(info, 1);
4151 if (NIL_P(path)) return Qnil;
4152 *pline = NUM2INT(line);
4153 return StringValue(path);
4154 }
4155
4156 void
4157 rb_error_frozen_object(VALUE frozen_obj)
4158 {
4159 rb_yjit_lazy_push_frame(GET_EC()->cfp->pc);
4160
4161 VALUE mesg = rb_sprintf("can't modify frozen %"PRIsVALUE": ",
4162 CLASS_OF(frozen_obj));
4163 VALUE exc = rb_exc_new_str(rb_eFrozenError, mesg);
4164
4165 rb_ivar_set(exc, id_recv, frozen_obj);
4166 rb_exec_recursive(inspect_frozen_obj, frozen_obj, mesg);
4167
4168 int created_line;
4169 VALUE created_path = get_created_info(frozen_obj, &created_line);
4170 if (!NIL_P(created_path)) {
4171 rb_str_catf(mesg, ", created at %"PRIsVALUE":%d", created_path, created_line);
4172 }
4173 rb_exc_raise(exc);
4174 }
4175
4176 void
4177 rb_warn_unchilled_literal(VALUE obj)
4178 {
4179 rb_warning_category_t category = RB_WARN_CATEGORY_DEPRECATED;
4180 if (!NIL_P(ruby_verbose) && rb_warning_category_enabled_p(category)) {
4181 int line;
4182 VALUE file = rb_source_location(&line);
4183 VALUE mesg = NIL_P(file) ? rb_str_new(0, 0) : rb_str_dup(file);
4184
4185 if (!NIL_P(file)) {
4186 if (line) rb_str_catf(mesg, ":%d", line);
4187 rb_str_cat2(mesg, ": ");
4188 }
4189 rb_str_cat2(mesg, "warning: literal string will be frozen in the future");
4190
4191 VALUE str = obj;
4192 if (STR_SHARED_P(str)) {
4193 str = RSTRING(obj)->as.heap.aux.shared;
4194 }
4195 VALUE created = get_created_info(str, &line);
4196 if (NIL_P(created)) {
4197 rb_str_cat2(mesg, " (run with --debug-frozen-string-literal for more information)\n");
4198 }
4199 else {
4200 rb_str_cat2(mesg, "\n");
4201 rb_str_append(mesg, created);
4202 if (line) rb_str_catf(mesg, ":%d", line);
4203 rb_str_cat2(mesg, ": info: the string was created here\n");
4204 }
4205 rb_warn_category(mesg, rb_warning_category_to_name(category));
4206 }
4207 }
4208
4209 void
4210 rb_warn_unchilled_symbol_to_s(VALUE obj)
4211 {
4212 rb_category_warn(
4213 RB_WARN_CATEGORY_DEPRECATED,
4214 "string returned by :%s.to_s will be frozen in the future", RSTRING_PTR(obj)
4215 );
4216 }
4217
4218 #undef rb_check_frozen
4219 void
4220 rb_check_frozen(VALUE obj)
4221 {
4222 rb_check_frozen_inline(obj);
4223 }
4224
4225 void
4226 rb_check_copyable(VALUE obj, VALUE orig)
4227 {
4228 if (!FL_ABLE(obj)) return;
4229 rb_check_frozen(obj);
4230 if (!FL_ABLE(orig)) return;
4231 }
4232
4233 void
4234 Init_syserr(void)
4235 {
4236 rb_eNOERROR = setup_syserr(0, "NOERROR");
4237 #if 0
4238 /* No error */
4239 rb_define_const(rb_mErrno, "NOERROR", rb_eNOERROR);
4240 #endif
4241 #define defined_error(name, num) set_syserr((num), (name));
4242 #define undefined_error(name) rb_define_const(rb_mErrno, (name), rb_eNOERROR);
4243 #include "known_errors.inc"
4244 #undef defined_error
4245 #undef undefined_error
4246 }
4247
4248 #include "warning.rbinc"
4249
4250 /*!
4251 * \}
4252 */
The Ruby Programming Language