Ruby: eval_error.c Source File

Ruby 3.4.4p34 (2025-05-14 revision a38531fd3f617bf734ef7d6c595325f69985ea1d)

eval_error.c
1/* -*-c-*- */
2/*
3 * included by eval.c
4 */
5
6#define write_warn(str, x) \
7 (NIL_P(str) ? warn_print(x) : (void)rb_str_cat_cstr(str, x))
8#define write_warn2(str, x, l) \
9 (NIL_P(str) ? warn_print2(x, l) : (void)rb_str_cat(str, x, l))
10#define write_warn_enc(str, x, l, enc) \
11 (NIL_P(str) ? warn_print2(x, l) : (void)rb_enc_str_buf_cat(str, x, l, enc))
12#ifdef HAVE_BUILTIN___BUILTIN_CONSTANT_P
13#define warn_print(x) RB_GNUC_EXTENSION_BLOCK( \
14 (__builtin_constant_p(x)) ? \
15 rb_write_error2((x), (long)strlen(x)) : \
16 rb_write_error(x) \
17)
18#else
19#define warn_print(x) rb_write_error(x)
20#endif
21
22#define warn_print2(x,l) rb_write_error2((x),(l))
23
24#define write_warn_str(str,x) NIL_P(str) ? rb_write_error_str(x) : (void)rb_str_concat((str), (x))
25#define warn_print_str(x) rb_write_error_str(x)
26
27static VALUE error_pos_str(void);
28
29static void
30error_pos(const VALUE str)
31{
32 VALUE pos = error_pos_str();
33 if (!NIL_P(pos)) {
34 write_warn_str(str, pos);
35 }
36}
37
38static VALUE
39error_pos_str(void)
40{
41 int sourceline;
42 VALUE sourcefile = rb_source_location(&sourceline);
43
44 if (!NIL_P(sourcefile)) {
45 ID caller_name;
46 if (sourceline == 0) {
47 return rb_sprintf("%"PRIsVALUE": ", sourcefile);
48 }
49 else if ((caller_name = rb_frame_callee()) != 0) {
50 return rb_sprintf("%"PRIsVALUE":%d:in '%"PRIsVALUE"': ",
51 sourcefile, sourceline,
52 rb_id2str(caller_name));
53 }
54 else {
55 return rb_sprintf("%"PRIsVALUE":%d: ", sourcefile, sourceline);
56 }
57 }
58 return Qnil;
59}
60
61static void
62set_backtrace(VALUE info, VALUE bt)
63{
64 ID set_backtrace = rb_intern("set_backtrace");
65
66 if (rb_backtrace_p(bt)) {
67 if (rb_method_basic_definition_p(CLASS_OF(info), set_backtrace)) {
68 rb_exc_set_backtrace(info, bt);
69 return;
70 }
71 else {
72 bt = rb_backtrace_to_str_ary(bt);
73 }
74 }
75 rb_check_funcall(info, set_backtrace, 1, &bt);
76}
77
78#define CSI_BEGIN "\033["
79#define CSI_SGR "m"
80
81static const char underline[] = CSI_BEGIN"1;4"CSI_SGR;
82static const char bold[] = CSI_BEGIN"1"CSI_SGR;
83static const char reset[] = CSI_BEGIN""CSI_SGR;
84
85static void
86print_errinfo(const VALUE eclass, const VALUE errat, const VALUE emesg, const VALUE str, int highlight)
87{
88 long elen = 0;
89 VALUE mesg;
90
91 if (NIL_P(errat) || RARRAY_LEN(errat) == 0 ||
92 NIL_P(mesg = RARRAY_AREF(errat, 0))) {
93 error_pos(str);
94 }
95 else {
96 write_warn_str(str, mesg);
97 write_warn(str, ": ");
98 }
99
100 if (!NIL_P(emesg)) {
101 elen = RSTRING_LEN(emesg);
102 }
103
104 if (eclass == rb_eRuntimeError && elen == 0) {
105 if (highlight) write_warn(str, underline);
106 write_warn(str, "unhandled exception");
107 if (highlight) write_warn(str, reset);
108 write_warn(str, "\n");
109 }
110 else {
111 VALUE epath;
112
113 epath = rb_class_name(eclass);
114 if (elen == 0) {
115 if (highlight) write_warn(str, underline);
116 write_warn_str(str, epath);
117 if (highlight) write_warn(str, reset);
118 write_warn(str, "\n");
119 }
120 else {
121 write_warn_str(str, emesg);
122 write_warn(str, "\n");
123 }
124 }
125}
126
127 VALUE
128rb_decorate_message(const VALUE eclass, VALUE emesg, int highlight)
129{
130 const char *einfo = "";
131 long elen = 0;
132 rb_encoding *eenc;
133
134 VALUE str = rb_usascii_str_new_cstr("");
135
136 if (!NIL_P(emesg) && rb_enc_asciicompat(eenc = rb_enc_get(emesg))) {
137 einfo = RSTRING_PTR(emesg);
138 elen = RSTRING_LEN(emesg);
139 }
140 else {
141 eenc = NULL;
142 }
143 if (eclass == rb_eRuntimeError && elen == 0) {
144 if (highlight) write_warn(str, underline);
145 write_warn(str, "unhandled exception");
146 if (highlight) write_warn(str, reset);
147 }
148 else {
149 VALUE epath;
150
151 epath = rb_class_name(eclass);
152 if (elen == 0) {
153 if (highlight) write_warn(str, underline);
154 write_warn_str(str, epath);
155 if (highlight) write_warn(str, reset);
156 }
157 else {
158 /* emesg is a String instance */
159 const char *tail = 0;
160
161 if (highlight) write_warn(str, bold);
162 if (RSTRING_PTR(epath)[0] == '#')
163 epath = 0;
164 if ((tail = memchr(einfo, '\n', elen)) != 0) {
165 write_warn_enc(str, einfo, tail - einfo, eenc);
166 tail++; /* skip newline */
167 }
168 else {
169 write_warn_str(str, emesg);
170 }
171 if (epath) {
172 write_warn(str, " (");
173 if (highlight) write_warn(str, underline);
174 write_warn_str(str, epath);
175 if (highlight) {
176 write_warn(str, reset);
177 write_warn(str, bold);
178 }
179 write_warn(str, ")");
180 if (highlight) write_warn(str, reset);
181 }
182 if (tail && einfo+elen > tail) {
183 if (!highlight) {
184 write_warn(str, "\n");
185 write_warn_enc(str, tail, einfo+elen-tail, eenc);
186 }
187 else {
188 elen -= tail - einfo;
189 einfo = tail;
190 write_warn(str, "\n");
191 while (elen > 0) {
192 tail = memchr(einfo, '\n', elen);
193 if (!tail || tail > einfo) {
194 write_warn(str, bold);
195 write_warn_enc(str, einfo, tail ? tail-einfo : elen, eenc);
196 write_warn(str, reset);
197 if (!tail) {
198 break;
199 }
200 }
201 elen -= tail - einfo;
202 einfo = tail;
203 do ++tail; while (tail < einfo+elen && *tail == '\n');
204 write_warn_enc(str, einfo, tail-einfo, eenc);
205 elen -= tail - einfo;
206 einfo = tail;
207 }
208 }
209 }
210 }
211 }
212
213 RB_GC_GUARD(emesg);
214
215 return str;
216}
217
218static void
219print_backtrace(const VALUE eclass, const VALUE errat, const VALUE str, int reverse, long backtrace_limit)
220{
221 if (!NIL_P(errat)) {
222 long i;
223 long len = RARRAY_LEN(errat);
224 const int threshold = 1000000000;
225 int width = (len <= 1) ? INT_MIN : ((int)log10((double)(len > threshold ?
226 ((len - 1) / threshold) :
227 len - 1)) +
228 (len < threshold ? 0 : 9) + 1);
229
230 long skip_start = -1, skip_len = 0;
231
232 // skip for stackoverflow
233 if (eclass == rb_eSysStackError) {
234 long trace_head = 9;
235 long trace_tail = 4;
236 long trace_max = trace_head + trace_tail + 5;
237 if (len > trace_max) {
238 skip_start = trace_head;
239 skip_len = len - trace_max + 5;
240 }
241 }
242
243 // skip for explicit limit
244 if (backtrace_limit >= 0 && len > backtrace_limit + 2) {
245 skip_start = backtrace_limit + 1;
246 skip_len = len - skip_start;
247 }
248
249 for (i = 1; i < len; i++) {
250 if (i == skip_start) {
251 write_warn_str(str, rb_sprintf("\t ... %ld levels...\n", skip_len));
252 i += skip_len;
253 if (i >= len) break;
254 }
255 VALUE line = RARRAY_AREF(errat, reverse ? len - i : i);
256 if (RB_TYPE_P(line, T_STRING)) {
257 VALUE bt = rb_str_new_cstr("\t");
258 if (reverse) rb_str_catf(bt, "%*ld: ", width, len - i);
259 write_warn_str(str, rb_str_catf(bt, "from %"PRIsVALUE"\n", line));
260 }
261 }
262 }
263}
264
265 VALUE rb_get_detailed_message(VALUE exc, VALUE opt);
266
267static int
268shown_cause_p(VALUE cause, VALUE *shown_causes)
269{
270 VALUE shown = *shown_causes;
271 if (!shown) {
272 *shown_causes = shown = rb_obj_hide(rb_ident_hash_new());
273 }
274 if (rb_hash_has_key(shown, cause)) return TRUE;
275 rb_hash_aset(shown, cause, Qtrue);
276 return FALSE;
277}
278
279static void
280show_cause(VALUE errinfo, VALUE str, VALUE opt, VALUE highlight, VALUE reverse, long backtrace_limit, VALUE *shown_causes)
281{
282 VALUE cause = rb_attr_get(errinfo, id_cause);
283 if (!NIL_P(cause) && rb_obj_is_kind_of(cause, rb_eException) &&
284 !shown_cause_p(cause, shown_causes)) {
285 volatile VALUE eclass = CLASS_OF(cause);
286 VALUE errat = rb_get_backtrace(cause);
287 VALUE emesg = rb_get_detailed_message(cause, opt);
288 if (reverse) {
289 show_cause(cause, str, opt, highlight, reverse, backtrace_limit, shown_causes);
290 print_backtrace(eclass, errat, str, TRUE, backtrace_limit);
291 print_errinfo(eclass, errat, emesg, str, RTEST(highlight));
292 }
293 else {
294 print_errinfo(eclass, errat, emesg, str, RTEST(highlight));
295 print_backtrace(eclass, errat, str, FALSE, backtrace_limit);
296 show_cause(cause, str, opt, highlight, reverse, backtrace_limit, shown_causes);
297 }
298 }
299}
300
301void
302rb_exc_check_circular_cause(VALUE exc)
303{
304 VALUE cause = exc, shown_causes = 0;
305 do {
306 if (shown_cause_p(cause, &shown_causes)) {
307 rb_raise(rb_eArgError, "circular causes");
308 }
309 } while (!NIL_P(cause = rb_attr_get(cause, id_cause)));
310}
311
312void
313rb_error_write(VALUE errinfo, VALUE emesg, VALUE errat, VALUE str, VALUE opt, VALUE highlight, VALUE reverse)
314{
315 volatile VALUE eclass;
316 VALUE shown_causes = 0;
317 long backtrace_limit = rb_backtrace_length_limit;
318
319 if (NIL_P(errinfo))
320 return;
321
322 if (UNDEF_P(errat)) {
323 errat = Qnil;
324 }
325 eclass = CLASS_OF(errinfo);
326 if (reverse) {
327 static const char traceback[] = "Traceback "
328 "(most recent call last):\n";
329 const int bold_part = rb_strlen_lit("Traceback");
330 char buff[sizeof(traceback)+sizeof(bold)+sizeof(reset)-2], *p = buff;
331 const char *msg = traceback;
332 long len = sizeof(traceback) - 1;
333 if (RTEST(highlight)) {
334#define APPEND(s, l) (memcpy(p, s, l), p += (l))
335 APPEND(bold, sizeof(bold)-1);
336 APPEND(traceback, bold_part);
337 APPEND(reset, sizeof(reset)-1);
338 APPEND(traceback + bold_part, sizeof(traceback)-bold_part-1);
339#undef APPEND
340 len = p - (msg = buff);
341 }
342 write_warn2(str, msg, len);
343 show_cause(errinfo, str, opt, highlight, reverse, backtrace_limit, &shown_causes);
344 print_backtrace(eclass, errat, str, TRUE, backtrace_limit);
345 print_errinfo(eclass, errat, emesg, str, RTEST(highlight));
346 }
347 else {
348 print_errinfo(eclass, errat, emesg, str, RTEST(highlight));
349 print_backtrace(eclass, errat, str, FALSE, backtrace_limit);
350 show_cause(errinfo, str, opt, highlight, reverse, backtrace_limit, &shown_causes);
351 }
352}
353
354static void
355rb_ec_error_print_detailed(rb_execution_context_t *const ec, const VALUE errinfo, const VALUE str, VALUE emesg0)
356{
357 volatile uint8_t raised_flag = ec->raised_flag;
358 volatile VALUE errat = Qundef;
359 volatile bool written = false;
360 volatile VALUE emesg = emesg0;
361
362 VALUE opt = rb_hash_new();
363 VALUE highlight = rb_stderr_tty_p() ? Qtrue : Qfalse;
364 rb_hash_aset(opt, ID2SYM(rb_intern_const("highlight")), highlight);
365
366 if (NIL_P(errinfo))
367 return;
368 rb_ec_raised_clear(ec);
369
370 EC_PUSH_TAG(ec);
371 if (EC_EXEC_TAG() == TAG_NONE) {
372 errat = rb_get_backtrace(errinfo);
373 }
374 if (UNDEF_P(emesg)) {
375 emesg = Qnil;
376 emesg = rb_get_detailed_message(errinfo, opt);
377 }
378
379 if (!written) {
380 written = true;
381 rb_error_write(errinfo, emesg, errat, str, opt, highlight, Qfalse);
382 }
383
384 EC_POP_TAG();
385 ec->errinfo = errinfo;
386 rb_ec_raised_set(ec, raised_flag);
387}
388
389void
390rb_ec_error_print(rb_execution_context_t *volatile ec, volatile VALUE errinfo)
391{
392 rb_ec_error_print_detailed(ec, errinfo, Qnil, Qundef);
393}
394
395#define undef_mesg_for(v, k) rb_fstring_lit("undefined"v" method '%1$s' for "k" '%2$s'")
396#define undef_mesg(v) ( \
397 is_mod ? \
398 undef_mesg_for(v, "module") : \
399 undef_mesg_for(v, "class"))
400
401void
402rb_print_undef(VALUE klass, ID id, rb_method_visibility_t visi)
403{
404 const int is_mod = RB_TYPE_P(klass, T_MODULE);
405 VALUE mesg;
406 switch (visi & METHOD_VISI_MASK) {
407 case METHOD_VISI_UNDEF:
408 case METHOD_VISI_PUBLIC: mesg = undef_mesg(""); break;
409 case METHOD_VISI_PRIVATE: mesg = undef_mesg(" private"); break;
410 case METHOD_VISI_PROTECTED: mesg = undef_mesg(" protected"); break;
411 default: UNREACHABLE;
412 }
413 rb_name_err_raise_str(mesg, klass, ID2SYM(id));
414}
415
416void
417rb_print_undef_str(VALUE klass, VALUE name)
418{
419 const int is_mod = RB_TYPE_P(klass, T_MODULE);
420 rb_name_err_raise_str(undef_mesg(""), klass, name);
421}
422
423#define inaccessible_mesg_for(v, k) rb_fstring_lit("method '%1$s' for "k" '%2$s' is "v)
424#define inaccessible_mesg(v) ( \
425 is_mod ? \
426 inaccessible_mesg_for(v, "module") : \
427 inaccessible_mesg_for(v, "class"))
428
429void
430rb_print_inaccessible(VALUE klass, ID id, rb_method_visibility_t visi)
431{
432 const int is_mod = RB_TYPE_P(klass, T_MODULE);
433 VALUE mesg;
434 switch (visi & METHOD_VISI_MASK) {
435 case METHOD_VISI_UNDEF:
436 case METHOD_VISI_PUBLIC: mesg = inaccessible_mesg(""); break;
437 case METHOD_VISI_PRIVATE: mesg = inaccessible_mesg("private"); break;
438 case METHOD_VISI_PROTECTED: mesg = inaccessible_mesg("protected"); break;
439 default: UNREACHABLE;
440 }
441 rb_name_err_raise_str(mesg, klass, ID2SYM(id));
442}
443
444static int
445sysexit_status(VALUE err)
446{
447 VALUE st = rb_ivar_get(err, id_status);
448 return NUM2INT(st);
449}
450
451enum {
452 EXITING_WITH_MESSAGE = 1,
453 EXITING_WITH_STATUS = 2,
454 EXITING_WITH_SIGNAL = 4
455};
456static int
457exiting_split(VALUE errinfo, volatile int *exitcode, volatile int *sigstatus)
458{
459 int ex = EXIT_SUCCESS;
460 VALUE signo;
461 int sig = 0;
462 int result = 0;
463
464 if (NIL_P(errinfo)) return 0;
465
466 if (THROW_DATA_P(errinfo)) {
467 int throw_state = ((const struct vm_throw_data *)errinfo)->throw_state;
468 ex = throw_state & VM_THROW_STATE_MASK;
469 result |= EXITING_WITH_STATUS;
470 }
471 else if (rb_obj_is_kind_of(errinfo, rb_eSystemExit)) {
472 ex = sysexit_status(errinfo);
473 result |= EXITING_WITH_STATUS;
474 }
475 else if (rb_obj_is_kind_of(errinfo, rb_eSignal)) {
476 signo = rb_ivar_get(errinfo, id_signo);
477 sig = FIX2INT(signo);
478 result |= EXITING_WITH_SIGNAL;
479 /* no message when exiting by signal */
480 if (signo == INT2FIX(SIGSEGV) || !rb_obj_is_instance_of(errinfo, rb_eSignal))
481 /* except for SEGV and subclasses */
482 result |= EXITING_WITH_MESSAGE;
483 }
484 else if (rb_obj_is_kind_of(errinfo, rb_eSystemCallError) &&
485 FIXNUM_P(signo = rb_attr_get(errinfo, id_signo))) {
486 sig = FIX2INT(signo);
487 result |= EXITING_WITH_SIGNAL;
488 /* no message when exiting by error to be mapped to signal */
489 }
490 else {
491 ex = EXIT_FAILURE;
492 result |= EXITING_WITH_STATUS | EXITING_WITH_MESSAGE;
493 }
494
495 if (exitcode && (result & EXITING_WITH_STATUS))
496 *exitcode = ex;
497 if (sigstatus && (result & EXITING_WITH_SIGNAL))
498 *sigstatus = sig;
499
500 return result;
501}
502
503#define unknown_longjmp_status(status) \
504 rb_bug("Unknown longjmp status %d", status)
505
506static int
507error_handle(rb_execution_context_t *ec, VALUE errinfo, enum ruby_tag_type ex)
508{
509 int status = EXIT_FAILURE;
510
511 if (rb_ec_set_raised(ec))
512 return EXIT_FAILURE;
513 switch (ex & TAG_MASK) {
514 case 0:
515 status = EXIT_SUCCESS;
516 break;
517
518 case TAG_RETURN:
519 error_pos(Qnil);
520 warn_print("unexpected return\n");
521 break;
522 case TAG_NEXT:
523 error_pos(Qnil);
524 warn_print("unexpected next\n");
525 break;
526 case TAG_BREAK:
527 error_pos(Qnil);
528 warn_print("unexpected break\n");
529 break;
530 case TAG_REDO:
531 error_pos(Qnil);
532 warn_print("unexpected redo\n");
533 break;
534 case TAG_RETRY:
535 error_pos(Qnil);
536 warn_print("retry outside of rescue clause\n");
537 break;
538 case TAG_THROW:
539 /* TODO: fix me */
540 error_pos(Qnil);
541 warn_print("unexpected throw\n");
542 break;
543 case TAG_RAISE:
544 if (!(exiting_split(errinfo, &status, NULL) & EXITING_WITH_MESSAGE)) {
545 break;
546 }
547 /* fallthrough */
548 case TAG_FATAL:
549 rb_ec_error_print(ec, errinfo);
550 break;
551 default:
552 unknown_longjmp_status(ex);
553 break;
554 }
555 rb_ec_reset_raised(ec);
556 return status;
557}
T_STRING
#define T_STRING
Old name of RUBY_T_STRING.
Definition value_type.h:78
Qundef
#define Qundef
Old name of RUBY_Qundef.
Definition special_consts.h:62
INT2FIX
#define INT2FIX
Old name of RB_INT2FIX.
Definition long.h:48
UNREACHABLE
#define UNREACHABLE
Old name of RBIMPL_UNREACHABLE.
Definition assume.h:28
ID2SYM
#define ID2SYM
Old name of RB_ID2SYM.
Definition symbol.h:44
CLASS_OF
#define CLASS_OF
Old name of rb_class_of.
Definition globals.h:203
FIX2INT
#define FIX2INT
Old name of RB_FIX2INT.
Definition int.h:41
T_MODULE
#define T_MODULE
Old name of RUBY_T_MODULE.
Definition value_type.h:70
Qtrue
#define Qtrue
Old name of RUBY_Qtrue.
Definition special_consts.h:61
NUM2INT
#define NUM2INT
Old name of RB_NUM2INT.
Definition int.h:44
Qnil
#define Qnil
Old name of RUBY_Qnil.
Definition special_consts.h:60
Qfalse
#define Qfalse
Old name of RUBY_Qfalse.
Definition special_consts.h:59
NIL_P
#define NIL_P
Old name of RB_NIL_P.
Definition special_consts.h:55
FIXNUM_P
#define FIXNUM_P
Old name of RB_FIXNUM_P.
Definition special_consts.h:53
rb_eSystemExit
VALUE rb_eSystemExit
SystemExit exception.
Definition error.c:1423
rb_eRuntimeError
VALUE rb_eRuntimeError
RuntimeError exception.
Definition error.c:1428
rb_eException
VALUE rb_eException
Mother of all exceptions.
Definition error.c:1422
rb_eSysStackError
VALUE rb_eSysStackError
SystemStackError exception.
Definition eval.c:50
rb_eSystemCallError
VALUE rb_eSystemCallError
SystemCallError exception.
Definition error.c:1450
rb_eSignal
VALUE rb_eSignal
SignalException exception.
Definition error.c:1425
rb_obj_hide
VALUE rb_obj_hide(VALUE obj)
Make the object invisible from Ruby code.
Definition object.c:104
rb_obj_is_instance_of
VALUE rb_obj_is_instance_of(VALUE obj, VALUE klass)
Queries if the given object is a direct instance of the given class.
Definition object.c:809
rb_obj_is_kind_of
VALUE rb_obj_is_kind_of(VALUE obj, VALUE klass)
Queries if the given object is an instance (of possibly descendants) of the given class.
Definition object.c:865
rb_usascii_str_new_cstr
#define rb_usascii_str_new_cstr(str)
Identical to rb_str_new_cstr, except it generates a string of "US ASCII" encoding.
Definition string.h:1567
rb_strlen_lit
#define rb_strlen_lit(str)
Length of a string literal.
Definition string.h:1692
rb_str_new_cstr
#define rb_str_new_cstr(str)
Identical to rb_str_new, except it assumes the passed pointer is a pointer to a C string.
Definition string.h:1514
rb_ivar_get
VALUE rb_ivar_get(VALUE obj, ID name)
Identical to rb_iv_get(), except it accepts the name as an ID instead of a C string.
Definition variable.c:1442
rb_class_name
VALUE rb_class_name(VALUE obj)
Queries the name of the given object's class.
Definition variable.c:492
rb_check_funcall
VALUE rb_check_funcall(VALUE recv, ID mid, int argc, const VALUE *argv)
Identical to rb_funcallv(), except it returns RUBY_Qundef instead of raising rb_eNoMethodError.
Definition vm_eval.c:668
rb_intern_const
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
Definition symbol.h:284
len
int len
Length of the buffer.
Definition io.h:8
RB_GC_GUARD
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
Definition memory.h:167
RARRAY_LEN
#define RARRAY_LEN
Just another name of rb_array_len.
Definition rarray.h:51
RARRAY_AREF
#define RARRAY_AREF(a, i)
Definition rarray.h:403
RTEST
#define RTEST
This is an old name of RB_TEST.
Definition special_consts.h:51
vm_throw_data
THROW_DATA.
Definition imemo.h:61
ID
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
Definition value.h:52
VALUE
uintptr_t VALUE
Type that represents a Ruby object.
Definition value.h:40
RB_TYPE_P
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.
Definition value_type.h:376