error.c

   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/ruby.h"
  13 #include "ruby/st.h"
  14 #include "vm_core.h"
  15
  16 #include <stdio.h>
  17 #include <stdarg.h>
  18 #ifdef HAVE_STDLIB_H
  19 #include <stdlib.h>
  20 #endif
  21 #ifndef EXIT_SUCCESS
  22 #define EXIT_SUCCESS 0
  23 #endif
  24
  25 extern const char ruby_description[];
  26
  27 static int
  28 err_position_0(char *buf, long len, const char *file, int line)
  29 {
  30     if (!file) {
  31         return 0;
  32     }
  33     else if (line == 0) {
  34         return snprintf(buf, len, "%s: ", file);
  35     }
  36     else {
  37         return snprintf(buf, len, "%s:%d: ", file, line);
  38     }
  39 }
  40
  41 static int
  42 err_position(char *buf, long len)
  43 {
  44     return err_position_0(buf, len, rb_sourcefile(), rb_sourceline());
  45 }
  46
  47 static void
  48 err_snprintf(char *buf, long len, const char *fmt, va_list args)
  49 {
  50     long n;
  51
  52     n = err_position(buf, len);
  53     if (len > n) {
  54         vsnprintf((char*)buf+n, len-n, fmt, args);
  55     }
  56 }
  57
  58 static void
  59 compile_snprintf(char *buf, long len, const char *file, int line, const char *fmt, va_list args)
  60 {
  61     long n;
  62
  63     n = err_position_0(buf, len, file, line);
  64     if (len > n) {
  65         vsnprintf((char*)buf+n, len-n, fmt, args);
  66     }
  67 }
  68
  69 static void err_append(const char*);
  70
  71 void
  72 rb_compile_error(const char *file, int line, const char *fmt, ...)
  73 {
  74     va_list args;
  75     char buf[BUFSIZ];
  76
  77     va_start(args, fmt);
  78     compile_snprintf(buf, BUFSIZ, file, line, fmt, args);
  79     va_end(args);
  80     err_append(buf);
  81 }
  82
  83 void
  84 rb_compile_error_append(const char *fmt, ...)
  85 {
  86     va_list args;
  87     char buf[BUFSIZ];
  88
  89     va_start(args, fmt);
  90     vsnprintf(buf, BUFSIZ, fmt, args);
  91     va_end(args);
  92     err_append(buf);
  93 }
  94
  95 static void
  96 compile_warn_print(const char *file, int line, const char *fmt, va_list args)
  97 {
  98     char buf[BUFSIZ];
  99     int len;
 100
 101     compile_snprintf(buf, BUFSIZ, file, line, fmt, args);
 102     len = strlen(buf);
 103     buf[len++] = '\n';
 104     rb_write_error2(buf, len);
 105 }
 106
 107 void
 108 rb_compile_warn(const char *file, int line, const char *fmt, ...)
 109 {
 110     char buf[BUFSIZ];
 111     va_list args;
 112
 113     if (NIL_P(ruby_verbose)) return;
 114
 115     snprintf(buf, BUFSIZ, "warning: %s", fmt);
 116
 117     va_start(args, fmt);
 118     compile_warn_print(file, line, buf, args);
 119     va_end(args);
 120 }
 121
 122 /* rb_compile_warning() reports only in verbose mode */
 123 void
 124 rb_compile_warning(const char *file, int line, const char *fmt, ...)
 125 {
 126     char buf[BUFSIZ];
 127     va_list args;
 128
 129     if (!RTEST(ruby_verbose)) return;
 130
 131     snprintf(buf, BUFSIZ, "warning: %s", fmt);
 132
 133     va_start(args, fmt);
 134     compile_warn_print(file, line, buf, args);
 135     va_end(args);
 136 }
 137
 138 static void
 139 warn_print(const char *fmt, va_list args)
 140 {
 141     char buf[BUFSIZ];
 142     int len;
 143
 144     err_snprintf(buf, BUFSIZ, fmt, args);
 145     len = strlen(buf);
 146     buf[len++] = '\n';
 147     rb_write_error2(buf, len);
 148 }
 149
 150 void
 151 rb_warn(const char *fmt, ...)
 152 {
 153     char buf[BUFSIZ];
 154     va_list args;
 155
 156     if (NIL_P(ruby_verbose)) return;
 157
 158     snprintf(buf, BUFSIZ, "warning: %s", fmt);
 159
 160     va_start(args, fmt);
 161     warn_print(buf, args);
 162     va_end(args);
 163 }
 164
 165 /* rb_warning() reports only in verbose mode */
 166 void
 167 rb_warning(const char *fmt, ...)
 168 {
 169     char buf[BUFSIZ];
 170     va_list args;
 171
 172     if (!RTEST(ruby_verbose)) return;
 173
 174     snprintf(buf, BUFSIZ, "warning: %s", fmt);
 175
 176     va_start(args, fmt);
 177     warn_print(buf, args);
 178     va_end(args);
 179 }
 180
 181 /*
 182  * call-seq:
 183  *    warn(msg)   => nil
 184  *
 185  * Display the given message (followed by a newline) on STDERR unless
 186  * warnings are disabled (for example with the <code>-W0</code> flag).
 187  */
 188
 189 static VALUE
 190 rb_warn_m(VALUE self, VALUE mesg)
 191 {
 192     if (!NIL_P(ruby_verbose)) {
 193         rb_io_write(rb_stderr, mesg);
 194         rb_io_write(rb_stderr, rb_default_rs);
 195     }
 196     return Qnil;
 197 }
 198
 199 void rb_vm_bugreport(void);
 200
 201 static void
 202 report_bug(const char *file, int line, const char *fmt, va_list args)
 203 {
 204     char buf[BUFSIZ];
 205     FILE *out = stderr;
 206     int len = err_position_0(buf, BUFSIZ, file, line);
 207
 208     if (fwrite(buf, 1, len, out) == len ||
 209         fwrite(buf, 1, len, (out = stdout)) == len) {
 210         fputs("[BUG] ", out);
 211         vfprintf(out, fmt, args);
 212         fprintf(out, "\n%s\n\n", ruby_description);
 213         rb_vm_bugreport();
 214     }
 215 }
 216
 217 void
 218 rb_bug(const char *fmt, ...)
 219 {
 220     va_list args;
 221
 222     va_start(args, fmt);
 223     report_bug(rb_sourcefile(), rb_sourceline(), fmt, args);
 224     va_end(args);
 225
 226     abort();
 227 }
 228
 229 void
 230 rb_compile_bug(const char *file, int line, const char *fmt, ...)
 231 {
 232     va_list args;
 233
 234     va_start(args, fmt);
 235     report_bug(file, line, fmt, args);
 236     va_end(args);
 237
 238     abort();
 239 }
 240
 241 static const struct types {
 242     int type;
 243     const char *name;
 244 } builtin_types[] = {
 245     {T_NIL,     "nil"},
 246     {T_OBJECT,  "Object"},
 247     {T_CLASS,   "Class"},
 248     {T_ICLASS,  "iClass"},      /* internal use: mixed-in module holder */
 249     {T_MODULE,  "Module"},
 250     {T_FLOAT,   "Float"},
 251     {T_STRING,  "String"},
 252     {T_REGEXP,  "Regexp"},
 253     {T_ARRAY,   "Array"},
 254     {T_FIXNUM,  "Fixnum"},
 255     {T_HASH,    "Hash"},
 256     {T_STRUCT,  "Struct"},
 257     {T_BIGNUM,  "Bignum"},
 258     {T_FILE,    "File"},
 259     {T_RATIONAL,"Rational"},
 260     {T_COMPLEX, "Complex"},
 261     {T_TRUE,    "true"},
 262     {T_FALSE,   "false"},
 263     {T_SYMBOL,  "Symbol"},      /* :symbol */
 264     {T_DATA,    "Data"},        /* internal use: wrapped C pointers */
 265     {T_MATCH,   "MatchData"},   /* data of $~ */
 266     {T_NODE,    "Node"},        /* internal use: syntax tree node */
 267     {T_UNDEF,   "undef"},       /* internal use: #undef; should not happen */
 268 };
 269
 270 void
 271 rb_check_type(VALUE x, int t)
 272 {
 273     const struct types *type = builtin_types;
 274     const struct types *const typeend = builtin_types +
 275         sizeof(builtin_types) / sizeof(builtin_types[0]);
 276
 277     if (x == Qundef) {
 278         rb_bug("undef leaked to the Ruby space");
 279     }
 280
 281     if (TYPE(x) != t) {
 282         while (type < typeend) {
 283             if (type->type == t) {
 284                 const char *etype;
 285
 286                 if (NIL_P(x)) {
 287                     etype = "nil";
 288                 }
 289                 else if (FIXNUM_P(x)) {
 290                     etype = "Fixnum";
 291                 }
 292                 else if (SYMBOL_P(x)) {
 293                     etype = "Symbol";
 294                 }
 295                 else if (rb_special_const_p(x)) {
 296                     etype = RSTRING_PTR(rb_obj_as_string(x));
 297                 }
 298                 else {
 299                     etype = rb_obj_classname(x);
 300                 }
 301                 rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)",
 302                          etype, type->name);
 303             }
 304             type++;
 305         }
 306         rb_bug("unknown type 0x%x (0x%x given)", t, TYPE(x));
 307     }
 308 }
 309
 310 /* exception classes */
 311 #include <errno.h>
 312
 313 VALUE rb_eException;
 314 VALUE rb_eSystemExit;
 315 VALUE rb_eInterrupt;
 316 VALUE rb_eSignal;
 317 VALUE rb_eFatal;
 318 VALUE rb_eStandardError;
 319 VALUE rb_eRuntimeError;
 320 VALUE rb_eTypeError;
 321 VALUE rb_eArgError;
 322 VALUE rb_eIndexError;
 323 VALUE rb_eKeyError;
 324 VALUE rb_eRangeError;
 325 VALUE rb_eNameError;
 326 VALUE rb_eNoMethodError;
 327 VALUE rb_eSecurityError;
 328 VALUE rb_eNotImpError;
 329 VALUE rb_eNoMemError;
 330 VALUE rb_cNameErrorMesg;
 331
 332 VALUE rb_eScriptError;
 333 VALUE rb_eSyntaxError;
 334 VALUE rb_eLoadError;
 335
 336 VALUE rb_eSystemCallError;
 337 VALUE rb_mErrno;
 338 static VALUE rb_eNOERROR;
 339
 340 VALUE
 341 rb_exc_new(VALUE etype, const char *ptr, long len)
 342 {
 343     return rb_funcall(etype, rb_intern("new"), 1, rb_str_new(ptr, len));
 344 }
 345
 346 VALUE
 347 rb_exc_new2(VALUE etype, const char *s)
 348 {
 349     return rb_exc_new(etype, s, strlen(s));
 350 }
 351
 352 VALUE
 353 rb_exc_new3(VALUE etype, VALUE str)
 354 {
 355     StringValue(str);
 356     return rb_funcall(etype, rb_intern("new"), 1, str);
 357 }
 358
 359 /*
 360  * call-seq:
 361  *    Exception.new(msg = nil)   =>  exception
 362  *
 363  *  Construct a new Exception object, optionally passing in
 364  *  a message.
 365  */
 366
 367 static VALUE
 368 exc_initialize(int argc, VALUE *argv, VALUE exc)
 369 {
 370     VALUE arg;
 371
 372     rb_scan_args(argc, argv, "01", &arg);
 373     rb_iv_set(exc, "mesg", arg);
 374     rb_iv_set(exc, "bt", Qnil);
 375
 376     return exc;
 377 }
 378
 379 /*
 380  *  Document-method: exception
 381  *
 382  *  call-seq:
 383  *     exc.exception(string) -> an_exception or exc
 384  *
 385  *  With no argument, or if the argument is the same as the receiver,
 386  *  return the receiver. Otherwise, create a new
 387  *  exception object of the same class as the receiver, but with a
 388  *  message equal to <code>string.to_str</code>.
 389  *
 390  */
 391
 392 static VALUE
 393 exc_exception(int argc, VALUE *argv, VALUE self)
 394 {
 395     VALUE exc;
 396
 397     if (argc == 0) return self;
 398     if (argc == 1 && self == argv[0]) return self;
 399     exc = rb_obj_clone(self);
 400     exc_initialize(argc, argv, exc);
 401
 402     return exc;
 403 }
 404
 405 /*
 406  * call-seq:
 407  *   exception.to_s   =>  string
 408  *
 409  * Returns exception's message (or the name of the exception if
 410  * no message is set).
 411  */
 412
 413 static VALUE
 414 exc_to_s(VALUE exc)
 415 {
 416     VALUE mesg = rb_attr_get(exc, rb_intern("mesg"));
 417
 418     if (NIL_P(mesg)) return rb_class_name(CLASS_OF(exc));
 419     if (OBJ_TAINTED(exc)) OBJ_TAINT(mesg);
 420     return mesg;
 421 }
 422
 423 /*
 424  * call-seq:
 425  *   exception.message   =>  string
 426  *
 427  * Returns the result of invoking <code>exception.to_s</code>.
 428  * Normally this returns the exception's message or name. By
 429  * supplying a to_str method, exceptions are agreeing to
 430  * be used where Strings are expected.
 431  */
 432
 433 static VALUE
 434 exc_message(VALUE exc)
 435 {
 436     return rb_funcall(exc, rb_intern("to_s"), 0, 0);
 437 }
 438
 439 /*
 440  * call-seq:
 441  *   exception.inspect   => string
 442  *
 443  * Return this exception's class name an message
 444  */
 445
 446 static VALUE
 447 exc_inspect(VALUE exc)
 448 {
 449     VALUE str, klass;
 450
 451     klass = CLASS_OF(exc);
 452     exc = rb_obj_as_string(exc);
 453     if (RSTRING_LEN(exc) == 0) {
 454         return rb_str_dup(rb_class_name(klass));
 455     }
 456
 457     str = rb_str_buf_new2("#<");
 458     klass = rb_class_name(klass);
 459     rb_str_buf_append(str, klass);
 460     rb_str_buf_cat(str, ": ", 2);
 461     rb_str_buf_append(str, exc);
 462     rb_str_buf_cat(str, ">", 1);
 463
 464     return str;
 465 }
 466
 467 /*
 468  *  call-seq:
 469  *     exception.backtrace    => array
 470  *
 471  *  Returns any backtrace associated with the exception. The backtrace
 472  *  is an array of strings, each containing either ``filename:lineNo: in
 473  *  `method''' or ``filename:lineNo.''
 474  *
 475  *     def a
 476  *       raise "boom"
 477  *     end
 478  *
 479  *     def b
 480  *       a()
 481  *     end
 482  *
 483  *     begin
 484  *       b()
 485  *     rescue => detail
 486  *       print detail.backtrace.join("\n")
 487  *     end
 488  *
 489  *  <em>produces:</em>
 490  *
 491  *     prog.rb:2:in `a'
 492  *     prog.rb:6:in `b'
 493  *     prog.rb:10
 494 */
 495
 496 static VALUE
 497 exc_backtrace(VALUE exc)
 498 {
 499     static ID bt;
 500
 501     if (!bt) bt = rb_intern("bt");
 502     return rb_attr_get(exc, bt);
 503 }
 504
 505 VALUE
 506 rb_check_backtrace(VALUE bt)
 507 {
 508     long i;
 509     static const char *err = "backtrace must be Array of String";
 510
 511     if (!NIL_P(bt)) {
 512         int t = TYPE(bt);
 513
 514         if (t == T_STRING) return rb_ary_new3(1, bt);
 515         if (t != T_ARRAY) {
 516             rb_raise(rb_eTypeError, err);
 517         }
 518         for (i=0;i<RARRAY_LEN(bt);i++) {
 519             if (TYPE(RARRAY_PTR(bt)[i]) != T_STRING) {
 520                 rb_raise(rb_eTypeError, err);
 521             }
 522         }
 523     }
 524     return bt;
 525 }
 526
 527 /*
 528  *  call-seq:
 529  *     exc.set_backtrace(array)   =>  array
 530  *
 531  *  Sets the backtrace information associated with <i>exc</i>. The
 532  *  argument must be an array of <code>String</code> objects in the
 533  *  format described in <code>Exception#backtrace</code>.
 534  *
 535  */
 536
 537 static VALUE
 538 exc_set_backtrace(VALUE exc, VALUE bt)
 539 {
 540     return rb_iv_set(exc, "bt", rb_check_backtrace(bt));
 541 }
 542
 543 /*
 544  *  call-seq:
 545  *     exc == obj   => true or false
 546  *
 547  *  Equality---If <i>obj</i> is not an <code>Exception</code>, returns
 548  *  <code>false</code>. Otherwise, returns <code>true</code> if <i>exc</i> and
 549  *  <i>obj</i> share same class, messages, and backtrace.
 550  */
 551
 552 static VALUE
 553 exc_equal(VALUE exc, VALUE obj)
 554 {
 555     ID id_mesg = rb_intern("mesg");
 556
 557     if (exc == obj) return Qtrue;
 558     if (rb_obj_class(exc) != rb_obj_class(obj))
 559         return Qfalse;
 560     if (!rb_equal(rb_attr_get(exc, id_mesg), rb_attr_get(obj, id_mesg)))
 561         return Qfalse;
 562     if (!rb_equal(exc_backtrace(exc), exc_backtrace(obj)))
 563         return Qfalse;
 564     return Qtrue;
 565 }
 566
 567 /*
 568  * call-seq:
 569  *   SystemExit.new(status=0)   => system_exit
 570  *
 571  * Create a new +SystemExit+ exception with the given status.
 572  */
 573
 574 static VALUE
 575 exit_initialize(int argc, VALUE *argv, VALUE exc)
 576 {
 577     VALUE status = INT2FIX(EXIT_SUCCESS);
 578     if (argc > 0 && FIXNUM_P(argv[0])) {
 579         status = *argv++;
 580         --argc;
 581     }
 582     rb_call_super(argc, argv);
 583     rb_iv_set(exc, "status", status);
 584     return exc;
 585 }
 586
 587
 588 /*
 589  * call-seq:
 590  *   system_exit.status   => fixnum
 591  *
 592  * Return the status value associated with this system exit.
 593  */
 594
 595 static VALUE
 596 exit_status(VALUE exc)
 597 {
 598     return rb_attr_get(exc, rb_intern("status"));
 599 }
 600
 601
 602 /*
 603  * call-seq:
 604  *   system_exit.success?  => true or false
 605  *
 606  * Returns +true+ if exiting successful, +false+ if not.
 607  */
 608
 609 static VALUE
 610 exit_success_p(VALUE exc)
 611 {
 612     VALUE status = rb_attr_get(exc, rb_intern("status"));
 613     if (NIL_P(status)) return Qtrue;
 614     if (status == INT2FIX(EXIT_SUCCESS)) return Qtrue;
 615     return Qfalse;
 616 }
 617
 618 void
 619 rb_name_error(ID id, const char *fmt, ...)
 620 {
 621     VALUE exc, argv[2];
 622     va_list args;
 623     char buf[BUFSIZ];
 624
 625     va_start(args, fmt);
 626     vsnprintf(buf, BUFSIZ, fmt, args);
 627     va_end(args);
 628
 629     argv[0] = rb_str_new2(buf);
 630     argv[1] = ID2SYM(id);
 631     exc = rb_class_new_instance(2, argv, rb_eNameError);
 632     rb_exc_raise(exc);
 633 }
 634
 635 /*
 636  * call-seq:
 637  *   NameError.new(msg [, name])  => name_error
 638  *
 639  * Construct a new NameError exception. If given the <i>name</i>
 640  * parameter may subsequently be examined using the <code>NameError.name</code>
 641  * method.
 642  */
 643
 644 static VALUE
 645 name_err_initialize(int argc, VALUE *argv, VALUE self)
 646 {
 647     VALUE name;
 648
 649     name = (argc > 1) ? argv[--argc] : Qnil;
 650     rb_call_super(argc, argv);
 651     rb_iv_set(self, "name", name);
 652     return self;
 653 }
 654
 655 /*
 656  *  call-seq:
 657  *    name_error.name    =>  string or nil
 658  *
 659  *  Return the name associated with this NameError exception.
 660  */
 661
 662 static VALUE
 663 name_err_name(VALUE self)
 664 {
 665     return rb_attr_get(self, rb_intern("name"));
 666 }
 667
 668 /*
 669  * call-seq:
 670  *  name_error.to_s   => string
 671  *
 672  * Produce a nicely-formatted string representing the +NameError+.
 673  */
 674
 675 static VALUE
 676 name_err_to_s(VALUE exc)
 677 {
 678     VALUE mesg = rb_attr_get(exc, rb_intern("mesg"));
 679     VALUE str = mesg;
 680
 681     if (NIL_P(mesg)) return rb_class_name(CLASS_OF(exc));
 682     StringValue(str);
 683     if (str != mesg) {
 684         rb_iv_set(exc, "mesg", mesg = str);
 685     }
 686     if (OBJ_TAINTED(exc)) OBJ_TAINT(mesg);
 687     return mesg;
 688 }
 689
 690 /*
 691  * call-seq:
 692  *   NoMethodError.new(msg, name [, args])  => no_method_error
 693  *
 694  * Construct a NoMethodError exception for a method of the given name
 695  * called with the given arguments. The name may be accessed using
 696  * the <code>#name</code> method on the resulting object, and the
 697  * arguments using the <code>#args</code> method.
 698  */
 699
 700 static VALUE
 701 nometh_err_initialize(int argc, VALUE *argv, VALUE self)
 702 {
 703     VALUE args = (argc > 2) ? argv[--argc] : Qnil;
 704     name_err_initialize(argc, argv, self);
 705     rb_iv_set(self, "args", args);
 706     return self;
 707 }
 708
 709 /* :nodoc: */
 710 static void
 711 name_err_mesg_mark(VALUE *ptr)
 712 {
 713     rb_gc_mark_locations(ptr, ptr+3);
 714 }
 715
 716 /* :nodoc: */
 717 static VALUE
 718 name_err_mesg_new(VALUE obj, VALUE mesg, VALUE recv, VALUE method)
 719 {
 720     VALUE *ptr = ALLOC_N(VALUE, 3);
 721
 722     ptr[0] = mesg;
 723     ptr[1] = recv;
 724     ptr[2] = method;
 725     return Data_Wrap_Struct(rb_cNameErrorMesg, name_err_mesg_mark, -1, ptr);
 726 }
 727
 728 /* :nodoc: */
 729 static VALUE
 730 name_err_mesg_equal(VALUE obj1, VALUE obj2)
 731 {
 732     VALUE *ptr1, *ptr2;
 733     int i;
 734
 735     if (obj1 == obj2) return Qtrue;
 736     if (rb_obj_class(obj2) != rb_cNameErrorMesg)
 737         return Qfalse;
 738
 739     Data_Get_Struct(obj1, VALUE, ptr1);
 740     Data_Get_Struct(obj2, VALUE, ptr2);
 741     for (i=0; i<3; i++) {
 742         if (!rb_equal(ptr1[i], ptr2[i]))
 743             return Qfalse;
 744     }
 745     return Qtrue;
 746 }
 747
 748 /* :nodoc: */
 749 static VALUE
 750 name_err_mesg_to_str(VALUE obj)
 751 {
 752     VALUE *ptr, mesg;
 753     Data_Get_Struct(obj, VALUE, ptr);
 754
 755     mesg = ptr[0];
 756     if (NIL_P(mesg)) return Qnil;
 757     else {
 758         const char *desc = 0;
 759         VALUE d = 0, args[3];
 760
 761         obj = ptr[1];
 762         switch (TYPE(obj)) {
 763           case T_NIL:
 764             desc = "nil";
 765             break;
 766           case T_TRUE:
 767             desc = "true";
 768             break;
 769           case T_FALSE:
 770             desc = "false";
 771             break;
 772           default:
 773             d = rb_protect(rb_inspect, obj, 0);
 774             if (NIL_P(d) || RSTRING_LEN(d) > 65) {
 775                 d = rb_any_to_s(obj);
 776             }
 777             desc = RSTRING_PTR(d);
 778             break;
 779         }
 780         if (desc && desc[0] != '#') {
 781             d = rb_str_new2(desc);
 782             rb_str_cat2(d, ":");
 783             rb_str_cat2(d, rb_obj_classname(obj));
 784         }
 785         args[0] = mesg;
 786         args[1] = ptr[2];
 787         args[2] = d;
 788         mesg = rb_f_sprintf(3, args);
 789     }
 790     if (OBJ_TAINTED(obj)) OBJ_TAINT(mesg);
 791     return mesg;
 792 }
 793
 794 /* :nodoc: */
 795 static VALUE
 796 name_err_mesg_load(VALUE klass, VALUE str)
 797 {
 798     return str;
 799 }
 800
 801 /*
 802  * call-seq:
 803  *   no_method_error.args  => obj
 804  *
 805  * Return the arguments passed in as the third parameter to
 806  * the constructor.
 807  */
 808
 809 static VALUE
 810 nometh_err_args(VALUE self)
 811 {
 812     return rb_attr_get(self, rb_intern("args"));
 813 }
 814
 815 void
 816 rb_invalid_str(const char *str, const char *type)
 817 {
 818     VALUE s = rb_str_inspect(rb_str_new2(str));
 819
 820     rb_raise(rb_eArgError, "invalid value for %s: %s", type, RSTRING_PTR(s));
 821 }
 822
 823 /*
 824  *  Document-module: Errno
 825  *
 826  *  Ruby exception objects are subclasses of <code>Exception</code>.
 827  *  However, operating systems typically report errors using plain
 828  *  integers. Module <code>Errno</code> is created dynamically to map
 829  *  these operating system errors to Ruby classes, with each error
 830  *  number generating its own subclass of <code>SystemCallError</code>.
 831  *  As the subclass is created in module <code>Errno</code>, its name
 832  *  will start <code>Errno::</code>.
 833  *
 834  *  The names of the <code>Errno::</code> classes depend on
 835  *  the environment in which Ruby runs. On a typical Unix or Windows
 836  *  platform, there are <code>Errno</code> classes such as
 837  *  <code>Errno::EACCES</code>, <code>Errno::EAGAIN</code>,
 838  *  <code>Errno::EINTR</code>, and so on.
 839  *
 840  *  The integer operating system error number corresponding to a
 841  *  particular error is available as the class constant
 842  *  <code>Errno::</code><em>error</em><code>::Errno</code>.
 843  *
 844  *     Errno::EACCES::Errno   #=> 13
 845  *     Errno::EAGAIN::Errno   #=> 11
 846  *     Errno::EINTR::Errno    #=> 4
 847  *
 848  *  The full list of operating system errors on your particular platform
 849  *  are available as the constants of <code>Errno</code>.
 850  *
 851  *     Errno.constants   #=> :E2BIG, :EACCES, :EADDRINUSE, :EADDRNOTAVAIL, ...
 852  */
 853
 854 static st_table *syserr_tbl;
 855
 856 static VALUE
 857 set_syserr(int n, const char *name)
 858 {
 859     VALUE error;
 860
 861     if (!st_lookup(syserr_tbl, n, &error)) {
 862         error = rb_define_class_under(rb_mErrno, name, rb_eSystemCallError);
 863         rb_define_const(error, "Errno", INT2NUM(n));
 864         st_add_direct(syserr_tbl, n, error);
 865     }
 866     else {
 867         rb_define_const(rb_mErrno, name, error);
 868     }
 869     return error;
 870 }
 871
 872 static VALUE
 873 get_syserr(int n)
 874 {
 875     VALUE error;
 876
 877     if (!st_lookup(syserr_tbl, n, &error)) {
 878         char name[8];   /* some Windows' errno have 5 digits. */
 879
 880         snprintf(name, sizeof(name), "E%03d", n);
 881         error = set_syserr(n, name);
 882     }
 883     return error;
 884 }
 885
 886 /*
 887  * call-seq:
 888  *   SystemCallError.new(msg, errno)  => system_call_error_subclass
 889  *
 890  * If _errno_ corresponds to a known system error code, constructs
 891  * the appropriate <code>Errno</code> class for that error, otherwise
 892  * constructs a generic <code>SystemCallError</code> object. The
 893  * error number is subsequently available via the <code>errno</code>
 894  * method.
 895  */
 896
 897 static VALUE
 898 syserr_initialize(int argc, VALUE *argv, VALUE self)
 899 {
 900 #if !defined(_WIN32) && !defined(__VMS)
 901     char *strerror();
 902 #endif
 903     const char *err;
 904     VALUE mesg, error;
 905     VALUE klass = rb_obj_class(self);
 906
 907     if (klass == rb_eSystemCallError) {
 908         rb_scan_args(argc, argv, "11", &mesg, &error);
 909         if (argc == 1 && FIXNUM_P(mesg)) {
 910             error = mesg; mesg = Qnil;
 911         }
 912         if (!NIL_P(error) && st_lookup(syserr_tbl, NUM2LONG(error), &klass)) {
 913             /* change class */
 914             if (TYPE(self) != T_OBJECT) { /* insurance to avoid type crash */
 915                 rb_raise(rb_eTypeError, "invalid instance type");
 916             }
 917             RBASIC(self)->klass = klass;
 918         }
 919     }
 920     else {
 921         rb_scan_args(argc, argv, "01", &mesg);
 922         error = rb_const_get(klass, rb_intern("Errno"));
 923     }
 924     if (!NIL_P(error)) err = strerror(NUM2LONG(error));
 925     else err = "unknown error";
 926     if (!NIL_P(mesg)) {
 927         VALUE str = mesg;
 928
 929         StringValue(str);
 930         mesg = rb_sprintf("%s - %.*s", err,
 931                           (int)RSTRING_LEN(str), RSTRING_PTR(str));
 932     }
 933     else {
 934         mesg = rb_str_new2(err);
 935     }
 936     rb_call_super(1, &mesg);
 937     rb_iv_set(self, "errno", error);
 938     return self;
 939 }
 940
 941 /*
 942  * call-seq:
 943  *   system_call_error.errno   => fixnum
 944  *
 945  * Return this SystemCallError's error number.
 946  */
 947
 948 static VALUE
 949 syserr_errno(VALUE self)
 950 {
 951     return rb_attr_get(self, rb_intern("errno"));
 952 }
 953
 954 /*
 955  * call-seq:
 956  *   system_call_error === other  => true or false
 957  *
 958  * Return +true+ if the receiver is a generic +SystemCallError+, or
 959  * if the error numbers _self_ and _other_ are the same.
 960  */
 961
 962 static VALUE
 963 syserr_eqq(VALUE self, VALUE exc)
 964 {
 965     VALUE num, e;
 966
 967     if (!rb_obj_is_kind_of(exc, rb_eSystemCallError)) return Qfalse;
 968     if (self == rb_eSystemCallError) return Qtrue;
 969
 970     num = rb_attr_get(exc, rb_intern("errno"));
 971     if (NIL_P(num)) {
 972         VALUE klass = CLASS_OF(exc);
 973
 974         while (TYPE(klass) == T_ICLASS || FL_TEST(klass, FL_SINGLETON)) {
 975             klass = (VALUE)RCLASS_SUPER(klass);
 976         }
 977         num = rb_const_get(klass, rb_intern("Errno"));
 978     }
 979     e = rb_const_get(self, rb_intern("Errno"));
 980     if (FIXNUM_P(num) ? num == e : rb_equal(num, e))
 981         return Qtrue;
 982     return Qfalse;
 983 }
 984
 985 /*
 986  * call-seq:
 987  *   Errno.const_missing   => SystemCallError
 988  *
 989  * Returns default SystemCallError class.
 990  */
 991 static VALUE
 992 errno_missing(VALUE self, VALUE id)
 993 {
 994     return rb_eNOERROR;
 995 }
 996
 997 /*
 998  *  Descendants of class <code>Exception</code> are used to communicate
 999  *  between <code>raise</code> methods and <code>rescue</code>
1000  *  statements in <code>begin/end</code> blocks. <code>Exception</code>
1001  *  objects carry information about the exception---its type (the
1002  *  exception's class name), an optional descriptive string, and
1003  *  optional traceback information. Programs may subclass
1004  *  <code>Exception</code> to add additional information.
1005  */
1006
1007 void
1008 Init_Exception(void)
1009 {
1010     rb_eException   = rb_define_class("Exception", rb_cObject);
1011     rb_define_singleton_method(rb_eException, "exception", rb_class_new_instance, -1);
1012     rb_define_method(rb_eException, "exception", exc_exception, -1);
1013     rb_define_method(rb_eException, "initialize", exc_initialize, -1);
1014     rb_define_method(rb_eException, "==", exc_equal, 1);
1015     rb_define_method(rb_eException, "to_s", exc_to_s, 0);
1016     rb_define_method(rb_eException, "message", exc_message, 0);
1017     rb_define_method(rb_eException, "inspect", exc_inspect, 0);
1018     rb_define_method(rb_eException, "backtrace", exc_backtrace, 0);
1019     rb_define_method(rb_eException, "set_backtrace", exc_set_backtrace, 1);
1020
1021     rb_eSystemExit  = rb_define_class("SystemExit", rb_eException);
1022     rb_define_method(rb_eSystemExit, "initialize", exit_initialize, -1);
1023     rb_define_method(rb_eSystemExit, "status", exit_status, 0);
1024     rb_define_method(rb_eSystemExit, "success?", exit_success_p, 0);
1025
1026     rb_eFatal       = rb_define_class("fatal", rb_eException);
1027     rb_eSignal      = rb_define_class("SignalException", rb_eException);
1028     rb_eInterrupt   = rb_define_class("Interrupt", rb_eSignal);
1029
1030     rb_eStandardError = rb_define_class("StandardError", rb_eException);
1031     rb_eTypeError     = rb_define_class("TypeError", rb_eStandardError);
1032     rb_eArgError      = rb_define_class("ArgumentError", rb_eStandardError);
1033     rb_eIndexError    = rb_define_class("IndexError", rb_eStandardError);
1034     rb_eKeyError      = rb_define_class("KeyError", rb_eIndexError);
1035     rb_eRangeError    = rb_define_class("RangeError", rb_eStandardError);
1036
1037     rb_eScriptError = rb_define_class("ScriptError", rb_eException);
1038     rb_eSyntaxError = rb_define_class("SyntaxError", rb_eScriptError);
1039     rb_eLoadError   = rb_define_class("LoadError", rb_eScriptError);
1040     rb_eNotImpError = rb_define_class("NotImplementedError", rb_eScriptError);
1041
1042     rb_eNameError     = rb_define_class("NameError", rb_eStandardError);
1043     rb_define_method(rb_eNameError, "initialize", name_err_initialize, -1);
1044     rb_define_method(rb_eNameError, "name", name_err_name, 0);
1045     rb_define_method(rb_eNameError, "to_s", name_err_to_s, 0);
1046     rb_cNameErrorMesg = rb_define_class_under(rb_eNameError, "message", rb_cData);
1047     rb_define_singleton_method(rb_cNameErrorMesg, "!", name_err_mesg_new, 3);
1048     rb_define_method(rb_cNameErrorMesg, "==", name_err_mesg_equal, 1);
1049     rb_define_method(rb_cNameErrorMesg, "to_str", name_err_mesg_to_str, 0);
1050     rb_define_method(rb_cNameErrorMesg, "_dump", name_err_mesg_to_str, 1);
1051     rb_define_singleton_method(rb_cNameErrorMesg, "_load", name_err_mesg_load, 1);
1052     rb_eNoMethodError = rb_define_class("NoMethodError", rb_eNameError);
1053     rb_define_method(rb_eNoMethodError, "initialize", nometh_err_initialize, -1);
1054     rb_define_method(rb_eNoMethodError, "args", nometh_err_args, 0);
1055
1056     rb_eRuntimeError = rb_define_class("RuntimeError", rb_eStandardError);
1057     rb_eSecurityError = rb_define_class("SecurityError", rb_eException);
1058     rb_eNoMemError = rb_define_class("NoMemoryError", rb_eException);
1059
1060     syserr_tbl = st_init_numtable();
1061     rb_eSystemCallError = rb_define_class("SystemCallError", rb_eStandardError);
1062     rb_define_method(rb_eSystemCallError, "initialize", syserr_initialize, -1);
1063     rb_define_method(rb_eSystemCallError, "errno", syserr_errno, 0);
1064     rb_define_singleton_method(rb_eSystemCallError, "===", syserr_eqq, 1);
1065
1066     rb_mErrno = rb_define_module("Errno");
1067     rb_define_singleton_method(rb_mErrno, "const_missing", errno_missing, 1);
1068
1069     rb_define_global_function("warn", rb_warn_m, 1);
1070 }
1071
1072 void
1073 rb_raise(VALUE exc, const char *fmt, ...)
1074 {
1075     va_list args;
1076     char buf[BUFSIZ];
1077
1078     va_start(args,fmt);
1079     vsnprintf(buf, BUFSIZ, fmt, args);
1080     va_end(args);
1081     rb_exc_raise(rb_exc_new2(exc, buf));
1082 }
1083
1084 void
1085 rb_loaderror(const char *fmt, ...)
1086 {
1087     va_list args;
1088     char buf[BUFSIZ];
1089
1090     va_start(args, fmt);
1091     vsnprintf(buf, BUFSIZ, fmt, args);
1092     va_end(args);
1093     rb_exc_raise(rb_exc_new2(rb_eLoadError, buf));
1094 }
1095
1096 void
1097 rb_notimplement(void)
1098 {
1099     rb_raise(rb_eNotImpError,
1100              "%s() function is unimplemented on this machine",
1101              rb_id2name(rb_frame_this_func()));
1102 }
1103
1104 void
1105 rb_fatal(const char *fmt, ...)
1106 {
1107     va_list args;
1108     char buf[BUFSIZ];
1109
1110     va_start(args, fmt);
1111     vsnprintf(buf, BUFSIZ, fmt, args);
1112     va_end(args);
1113
1114     rb_exc_fatal(rb_exc_new2(rb_eFatal, buf));
1115 }
1116
1117 void
1118 rb_sys_fail(const char *mesg)
1119 {
1120     int n = errno;
1121     VALUE arg;
1122
1123     errno = 0;
1124     if (n == 0) {
1125         rb_bug("rb_sys_fail(%s) - errno == 0", mesg ? mesg : "");
1126     }
1127
1128     arg = mesg ? rb_str_new2(mesg) : Qnil;
1129     rb_exc_raise(rb_class_new_instance(1, &arg, get_syserr(n)));
1130 }
1131
1132 void
1133 rb_sys_warning(const char *fmt, ...)
1134 {
1135     char buf[BUFSIZ];
1136     va_list args;
1137     int errno_save;
1138
1139     errno_save = errno;
1140
1141     if (!RTEST(ruby_verbose)) return;
1142
1143     snprintf(buf, BUFSIZ, "warning: %s", fmt);
1144     snprintf(buf+strlen(buf), BUFSIZ-strlen(buf), ": %s", strerror(errno_save));
1145
1146     va_start(args, fmt);
1147     warn_print(buf, args);
1148     va_end(args);
1149     errno = errno_save;
1150 }
1151
1152 void
1153 rb_load_fail(const char *path)
1154 {
1155     rb_loaderror("%s -- %s", strerror(errno), path);
1156 }
1157
1158 void
1159 rb_error_frozen(const char *what)
1160 {
1161     rb_raise(rb_eRuntimeError, "can't modify frozen %s", what);
1162 }
1163
1164 void
1165 rb_check_frozen(VALUE obj)
1166 {
1167     if (OBJ_FROZEN(obj)) rb_error_frozen(rb_obj_classname(obj));
1168 }
1169
1170 void
1171 Init_syserr(void)
1172 {
1173 #ifdef EPERM
1174     set_syserr(EPERM, "EPERM");
1175 #endif
1176 #ifdef ENOENT
1177     set_syserr(ENOENT, "ENOENT");
1178 #endif
1179 #ifdef ESRCH
1180     set_syserr(ESRCH, "ESRCH");
1181 #endif
1182 #ifdef EINTR
1183     set_syserr(EINTR, "EINTR");
1184 #endif
1185 #ifdef EIO
1186     set_syserr(EIO, "EIO");
1187 #endif
1188 #ifdef ENXIO
1189     set_syserr(ENXIO, "ENXIO");
1190 #endif
1191 #ifdef E2BIG
1192     set_syserr(E2BIG, "E2BIG");
1193 #endif
1194 #ifdef ENOEXEC
1195     set_syserr(ENOEXEC, "ENOEXEC");
1196 #endif
1197 #ifdef EBADF
1198     set_syserr(EBADF, "EBADF");
1199 #endif
1200 #ifdef ECHILD
1201     set_syserr(ECHILD, "ECHILD");
1202 #endif
1203 #ifdef EAGAIN
1204     set_syserr(EAGAIN, "EAGAIN");
1205 #endif
1206 #ifdef ENOMEM
1207     set_syserr(ENOMEM, "ENOMEM");
1208 #endif
1209 #ifdef EACCES
1210     set_syserr(EACCES, "EACCES");
1211 #endif
1212 #ifdef EFAULT
1213     set_syserr(EFAULT, "EFAULT");
1214 #endif
1215 #ifdef ENOTBLK
1216     set_syserr(ENOTBLK, "ENOTBLK");
1217 #endif
1218 #ifdef EBUSY
1219     set_syserr(EBUSY, "EBUSY");
1220 #endif
1221 #ifdef EEXIST
1222     set_syserr(EEXIST, "EEXIST");
1223 #endif
1224 #ifdef EXDEV
1225     set_syserr(EXDEV, "EXDEV");
1226 #endif
1227 #ifdef ENODEV
1228     set_syserr(ENODEV, "ENODEV");
1229 #endif
1230 #ifdef ENOTDIR
1231     set_syserr(ENOTDIR, "ENOTDIR");
1232 #endif
1233 #ifdef EISDIR
1234     set_syserr(EISDIR, "EISDIR");
1235 #endif
1236 #ifdef EINVAL
1237     set_syserr(EINVAL, "EINVAL");
1238 #endif
1239 #ifdef ENFILE
1240     set_syserr(ENFILE, "ENFILE");
1241 #endif
1242 #ifdef EMFILE
1243     set_syserr(EMFILE, "EMFILE");
1244 #endif
1245 #ifdef ENOTTY
1246     set_syserr(ENOTTY, "ENOTTY");
1247 #endif
1248 #ifdef ETXTBSY
1249     set_syserr(ETXTBSY, "ETXTBSY");
1250 #endif
1251 #ifdef EFBIG
1252     set_syserr(EFBIG, "EFBIG");
1253 #endif
1254 #ifdef ENOSPC
1255     set_syserr(ENOSPC, "ENOSPC");
1256 #endif
1257 #ifdef ESPIPE
1258     set_syserr(ESPIPE, "ESPIPE");
1259 #endif
1260 #ifdef EROFS
1261     set_syserr(EROFS, "EROFS");
1262 #endif
1263 #ifdef EMLINK
1264     set_syserr(EMLINK, "EMLINK");
1265 #endif
1266 #ifdef EPIPE
1267     set_syserr(EPIPE, "EPIPE");
1268 #endif
1269 #ifdef EDOM
1270     set_syserr(EDOM, "EDOM");
1271 #endif
1272 #ifdef ERANGE
1273     set_syserr(ERANGE, "ERANGE");
1274 #endif
1275 #ifdef EDEADLK
1276     set_syserr(EDEADLK, "EDEADLK");
1277 #endif
1278 #ifdef ENAMETOOLONG
1279     set_syserr(ENAMETOOLONG, "ENAMETOOLONG");
1280 #endif
1281 #ifdef ENOLCK
1282     set_syserr(ENOLCK, "ENOLCK");
1283 #endif
1284 #ifdef ENOSYS
1285     set_syserr(ENOSYS, "ENOSYS");
1286 #endif
1287 #ifdef ENOTEMPTY
1288     set_syserr(ENOTEMPTY, "ENOTEMPTY");
1289 #endif
1290 #ifdef ELOOP
1291     set_syserr(ELOOP, "ELOOP");
1292 #endif
1293 #ifdef EWOULDBLOCK
1294     set_syserr(EWOULDBLOCK, "EWOULDBLOCK");
1295 #endif
1296 #ifdef ENOMSG
1297     set_syserr(ENOMSG, "ENOMSG");
1298 #endif
1299 #ifdef EIDRM
1300     set_syserr(EIDRM, "EIDRM");
1301 #endif
1302 #ifdef ECHRNG
1303     set_syserr(ECHRNG, "ECHRNG");
1304 #endif
1305 #ifdef EL2NSYNC
1306     set_syserr(EL2NSYNC, "EL2NSYNC");
1307 #endif
1308 #ifdef EL3HLT
1309     set_syserr(EL3HLT, "EL3HLT");
1310 #endif
1311 #ifdef EL3RST
1312     set_syserr(EL3RST, "EL3RST");
1313 #endif
1314 #ifdef ELNRNG
1315     set_syserr(ELNRNG, "ELNRNG");
1316 #endif
1317 #ifdef EUNATCH
1318     set_syserr(EUNATCH, "EUNATCH");
1319 #endif
1320 #ifdef ENOCSI
1321     set_syserr(ENOCSI, "ENOCSI");
1322 #endif
1323 #ifdef EL2HLT
1324     set_syserr(EL2HLT, "EL2HLT");
1325 #endif
1326 #ifdef EBADE
1327     set_syserr(EBADE, "EBADE");
1328 #endif
1329 #ifdef EBADR
1330     set_syserr(EBADR, "EBADR");
1331 #endif
1332 #ifdef EXFULL
1333     set_syserr(EXFULL, "EXFULL");
1334 #endif
1335 #ifdef ENOANO
1336     set_syserr(ENOANO, "ENOANO");
1337 #endif
1338 #ifdef EBADRQC
1339     set_syserr(EBADRQC, "EBADRQC");
1340 #endif
1341 #ifdef EBADSLT
1342     set_syserr(EBADSLT, "EBADSLT");
1343 #endif
1344 #ifdef EDEADLOCK
1345     set_syserr(EDEADLOCK, "EDEADLOCK");
1346 #endif
1347 #ifdef EBFONT
1348     set_syserr(EBFONT, "EBFONT");
1349 #endif
1350 #ifdef ENOSTR
1351     set_syserr(ENOSTR, "ENOSTR");
1352 #endif
1353 #ifdef ENODATA
1354     set_syserr(ENODATA, "ENODATA");
1355 #endif
1356 #ifdef ETIME
1357     set_syserr(ETIME, "ETIME");
1358 #endif
1359 #ifdef ENOSR
1360     set_syserr(ENOSR, "ENOSR");
1361 #endif
1362 #ifdef ENONET
1363     set_syserr(ENONET, "ENONET");
1364 #endif
1365 #ifdef ENOPKG
1366     set_syserr(ENOPKG, "ENOPKG");
1367 #endif
1368 #ifdef EREMOTE
1369     set_syserr(EREMOTE, "EREMOTE");
1370 #endif
1371 #ifdef ENOLINK
1372     set_syserr(ENOLINK, "ENOLINK");
1373 #endif
1374 #ifdef EADV
1375     set_syserr(EADV, "EADV");
1376 #endif
1377 #ifdef ESRMNT
1378     set_syserr(ESRMNT, "ESRMNT");
1379 #endif
1380 #ifdef ECOMM
1381     set_syserr(ECOMM, "ECOMM");
1382 #endif
1383 #ifdef EPROTO
1384     set_syserr(EPROTO, "EPROTO");
1385 #endif
1386 #ifdef EMULTIHOP
1387     set_syserr(EMULTIHOP, "EMULTIHOP");
1388 #endif
1389 #ifdef EDOTDOT
1390     set_syserr(EDOTDOT, "EDOTDOT");
1391 #endif
1392 #ifdef EBADMSG
1393     set_syserr(EBADMSG, "EBADMSG");
1394 #endif
1395 #ifdef EOVERFLOW
1396     set_syserr(EOVERFLOW, "EOVERFLOW");
1397 #endif
1398 #ifdef ENOTUNIQ
1399     set_syserr(ENOTUNIQ, "ENOTUNIQ");
1400 #endif
1401 #ifdef EBADFD
1402     set_syserr(EBADFD, "EBADFD");
1403 #endif
1404 #ifdef EREMCHG
1405     set_syserr(EREMCHG, "EREMCHG");
1406 #endif
1407 #ifdef ELIBACC
1408     set_syserr(ELIBACC, "ELIBACC");
1409 #endif
1410 #ifdef ELIBBAD
1411     set_syserr(ELIBBAD, "ELIBBAD");
1412 #endif
1413 #ifdef ELIBSCN
1414     set_syserr(ELIBSCN, "ELIBSCN");
1415 #endif
1416 #ifdef ELIBMAX
1417     set_syserr(ELIBMAX, "ELIBMAX");
1418 #endif
1419 #ifdef ELIBEXEC
1420     set_syserr(ELIBEXEC, "ELIBEXEC");
1421 #endif
1422 #ifdef EILSEQ
1423     set_syserr(EILSEQ, "EILSEQ");
1424 #endif
1425 #ifdef ERESTART
1426     set_syserr(ERESTART, "ERESTART");
1427 #endif
1428 #ifdef ESTRPIPE
1429     set_syserr(ESTRPIPE, "ESTRPIPE");
1430 #endif
1431 #ifdef EUSERS
1432     set_syserr(EUSERS, "EUSERS");
1433 #endif
1434 #ifdef ENOTSOCK
1435     set_syserr(ENOTSOCK, "ENOTSOCK");
1436 #endif
1437 #ifdef EDESTADDRREQ
1438     set_syserr(EDESTADDRREQ, "EDESTADDRREQ");
1439 #endif
1440 #ifdef EMSGSIZE
1441     set_syserr(EMSGSIZE, "EMSGSIZE");
1442 #endif
1443 #ifdef EPROTOTYPE
1444     set_syserr(EPROTOTYPE, "EPROTOTYPE");
1445 #endif
1446 #ifdef ENOPROTOOPT
1447     set_syserr(ENOPROTOOPT, "ENOPROTOOPT");
1448 #endif
1449 #ifdef EPROTONOSUPPORT
1450     set_syserr(EPROTONOSUPPORT, "EPROTONOSUPPORT");
1451 #endif
1452 #ifdef ESOCKTNOSUPPORT
1453     set_syserr(ESOCKTNOSUPPORT, "ESOCKTNOSUPPORT");
1454 #endif
1455 #ifdef EOPNOTSUPP
1456     set_syserr(EOPNOTSUPP, "EOPNOTSUPP");
1457 #endif
1458 #ifdef EPFNOSUPPORT
1459     set_syserr(EPFNOSUPPORT, "EPFNOSUPPORT");
1460 #endif
1461 #ifdef EAFNOSUPPORT
1462     set_syserr(EAFNOSUPPORT, "EAFNOSUPPORT");
1463 #endif
1464 #ifdef EADDRINUSE
1465     set_syserr(EADDRINUSE, "EADDRINUSE");
1466 #endif
1467 #ifdef EADDRNOTAVAIL
1468     set_syserr(EADDRNOTAVAIL, "EADDRNOTAVAIL");
1469 #endif
1470 #ifdef ENETDOWN
1471     set_syserr(ENETDOWN, "ENETDOWN");
1472 #endif
1473 #ifdef ENETUNREACH
1474     set_syserr(ENETUNREACH, "ENETUNREACH");
1475 #endif
1476 #ifdef ENETRESET
1477     set_syserr(ENETRESET, "ENETRESET");
1478 #endif
1479 #ifdef ECONNABORTED
1480     set_syserr(ECONNABORTED, "ECONNABORTED");
1481 #endif
1482 #ifdef ECONNRESET
1483     set_syserr(ECONNRESET, "ECONNRESET");
1484 #endif
1485 #ifdef ENOBUFS
1486     set_syserr(ENOBUFS, "ENOBUFS");
1487 #endif
1488 #ifdef EISCONN
1489     set_syserr(EISCONN, "EISCONN");
1490 #endif
1491 #ifdef ENOTCONN
1492     set_syserr(ENOTCONN, "ENOTCONN");
1493 #endif
1494 #ifdef ESHUTDOWN
1495     set_syserr(ESHUTDOWN, "ESHUTDOWN");
1496 #endif
1497 #ifdef ETOOMANYREFS
1498     set_syserr(ETOOMANYREFS, "ETOOMANYREFS");
1499 #endif
1500 #ifdef ETIMEDOUT
1501     set_syserr(ETIMEDOUT, "ETIMEDOUT");
1502 #endif
1503 #ifdef ECONNREFUSED
1504     set_syserr(ECONNREFUSED, "ECONNREFUSED");
1505 #endif
1506 #ifdef EHOSTDOWN
1507     set_syserr(EHOSTDOWN, "EHOSTDOWN");
1508 #endif
1509 #ifdef EHOSTUNREACH
1510     set_syserr(EHOSTUNREACH, "EHOSTUNREACH");
1511 #endif
1512 #ifdef EALREADY
1513     set_syserr(EALREADY, "EALREADY");
1514 #endif
1515 #ifdef EINPROGRESS
1516     set_syserr(EINPROGRESS, "EINPROGRESS");
1517 #endif
1518 #ifdef ESTALE
1519     set_syserr(ESTALE, "ESTALE");
1520 #endif
1521 #ifdef EUCLEAN
1522     set_syserr(EUCLEAN, "EUCLEAN");
1523 #endif
1524 #ifdef ENOTNAM
1525     set_syserr(ENOTNAM, "ENOTNAM");
1526 #endif
1527 #ifdef ENAVAIL
1528     set_syserr(ENAVAIL, "ENAVAIL");
1529 #endif
1530 #ifdef EISNAM
1531     set_syserr(EISNAM, "EISNAM");
1532 #endif
1533 #ifdef EREMOTEIO
1534     set_syserr(EREMOTEIO, "EREMOTEIO");
1535 #endif
1536 #ifdef EDQUOT
1537     set_syserr(EDQUOT, "EDQUOT");
1538 #endif
1539     rb_eNOERROR = set_syserr(0, "NOERROR");
1540 }
1541
1542 static void
1543 err_append(const char *s)
1544 {
1545     rb_thread_t *th = GET_THREAD();
1546     VALUE err = th->errinfo;
1547
1548     if (th->parse_in_eval) {
1549         if (!RTEST(err)) {
1550             err = rb_exc_new2(rb_eSyntaxError, s);
1551             th->errinfo = err;
1552         }
1553         else {
1554             VALUE str = rb_obj_as_string(err);
1555
1556             rb_str_cat2(str, "\n");
1557             rb_str_cat2(str, s);
1558             th->errinfo = rb_exc_new3(rb_eSyntaxError, str);
1559         }
1560     }
1561     else {
1562         if (!RTEST(err)) {
1563             err = rb_exc_new2(rb_eSyntaxError, "compile error");
1564             th->errinfo = err;
1565         }
1566         rb_write_error(s);
1567         rb_write_error("\n");
1568     }
1569 }