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     ID bt;
 500
 501     CONST_ID(bt, "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;
 556
 557     if (exc == obj) return Qtrue;
 558     if (rb_obj_class(exc) != rb_obj_class(obj))
 559         return rb_equal(obj, exc);
 560     CONST_ID(id_mesg, "mesg");
 561     if (!rb_equal(rb_attr_get(exc, id_mesg), rb_attr_get(obj, id_mesg)))
 562         return Qfalse;
 563     if (!rb_equal(exc_backtrace(exc), exc_backtrace(obj)))
 564         return Qfalse;
 565     return Qtrue;
 566 }
 567
 568 /*
 569  * call-seq:
 570  *   SystemExit.new(status=0)   => system_exit
 571  *
 572  * Create a new +SystemExit+ exception with the given status.
 573  */
 574
 575 static VALUE
 576 exit_initialize(int argc, VALUE *argv, VALUE exc)
 577 {
 578     VALUE status = INT2FIX(EXIT_SUCCESS);
 579     if (argc > 0 && FIXNUM_P(argv[0])) {
 580         status = *argv++;
 581         --argc;
 582     }
 583     rb_call_super(argc, argv);
 584     rb_iv_set(exc, "status", status);
 585     return exc;
 586 }
 587
 588
 589 /*
 590  * call-seq:
 591  *   system_exit.status   => fixnum
 592  *
 593  * Return the status value associated with this system exit.
 594  */
 595
 596 static VALUE
 597 exit_status(VALUE exc)
 598 {
 599     return rb_attr_get(exc, rb_intern("status"));
 600 }
 601
 602
 603 /*
 604  * call-seq:
 605  *   system_exit.success?  => true or false
 606  *
 607  * Returns +true+ if exiting successful, +false+ if not.
 608  */
 609
 610 static VALUE
 611 exit_success_p(VALUE exc)
 612 {
 613     VALUE status = rb_attr_get(exc, rb_intern("status"));
 614     if (NIL_P(status)) return Qtrue;
 615     if (status == INT2FIX(EXIT_SUCCESS)) return Qtrue;
 616     return Qfalse;
 617 }
 618
 619 void
 620 rb_name_error(ID id, const char *fmt, ...)
 621 {
 622     VALUE exc, argv[2];
 623     va_list args;
 624     char buf[BUFSIZ];
 625
 626     va_start(args, fmt);
 627     vsnprintf(buf, BUFSIZ, fmt, args);
 628     va_end(args);
 629
 630     argv[0] = rb_str_new2(buf);
 631     argv[1] = ID2SYM(id);
 632     exc = rb_class_new_instance(2, argv, rb_eNameError);
 633     rb_exc_raise(exc);
 634 }
 635
 636 /*
 637  * call-seq:
 638  *   NameError.new(msg [, name])  => name_error
 639  *
 640  * Construct a new NameError exception. If given the <i>name</i>
 641  * parameter may subsequently be examined using the <code>NameError.name</code>
 642  * method.
 643  */
 644
 645 static VALUE
 646 name_err_initialize(int argc, VALUE *argv, VALUE self)
 647 {
 648     VALUE name;
 649
 650     name = (argc > 1) ? argv[--argc] : Qnil;
 651     rb_call_super(argc, argv);
 652     rb_iv_set(self, "name", name);
 653     return self;
 654 }
 655
 656 /*
 657  *  call-seq:
 658  *    name_error.name    =>  string or nil
 659  *
 660  *  Return the name associated with this NameError exception.
 661  */
 662
 663 static VALUE
 664 name_err_name(VALUE self)
 665 {
 666     return rb_attr_get(self, rb_intern("name"));
 667 }
 668
 669 /*
 670  * call-seq:
 671  *  name_error.to_s   => string
 672  *
 673  * Produce a nicely-formatted string representing the +NameError+.
 674  */
 675
 676 static VALUE
 677 name_err_to_s(VALUE exc)
 678 {
 679     VALUE mesg = rb_attr_get(exc, rb_intern("mesg"));
 680     VALUE str = mesg;
 681
 682     if (NIL_P(mesg)) return rb_class_name(CLASS_OF(exc));
 683     StringValue(str);
 684     if (str != mesg) {
 685         rb_iv_set(exc, "mesg", mesg = str);
 686     }
 687     if (OBJ_TAINTED(exc)) OBJ_TAINT(mesg);
 688     return mesg;
 689 }
 690
 691 /*
 692  * call-seq:
 693  *   NoMethodError.new(msg, name [, args])  => no_method_error
 694  *
 695  * Construct a NoMethodError exception for a method of the given name
 696  * called with the given arguments. The name may be accessed using
 697  * the <code>#name</code> method on the resulting object, and the
 698  * arguments using the <code>#args</code> method.
 699  */
 700
 701 static VALUE
 702 nometh_err_initialize(int argc, VALUE *argv, VALUE self)
 703 {
 704     VALUE args = (argc > 2) ? argv[--argc] : Qnil;
 705     name_err_initialize(argc, argv, self);
 706     rb_iv_set(self, "args", args);
 707     return self;
 708 }
 709
 710 /* :nodoc: */
 711 static void
 712 name_err_mesg_mark(VALUE *ptr)
 713 {
 714     rb_gc_mark_locations(ptr, ptr+3);
 715 }
 716
 717 /* :nodoc: */
 718 static VALUE
 719 name_err_mesg_new(VALUE obj, VALUE mesg, VALUE recv, VALUE method)
 720 {
 721     VALUE *ptr = ALLOC_N(VALUE, 3);
 722
 723     ptr[0] = mesg;
 724     ptr[1] = recv;
 725     ptr[2] = method;
 726     return Data_Wrap_Struct(rb_cNameErrorMesg, name_err_mesg_mark, -1, ptr);
 727 }
 728
 729 /* :nodoc: */
 730 static VALUE
 731 name_err_mesg_equal(VALUE obj1, VALUE obj2)
 732 {
 733     VALUE *ptr1, *ptr2;
 734     int i;
 735
 736     if (obj1 == obj2) return Qtrue;
 737     if (rb_obj_class(obj2) != rb_cNameErrorMesg)
 738         return Qfalse;
 739
 740     Data_Get_Struct(obj1, VALUE, ptr1);
 741     Data_Get_Struct(obj2, VALUE, ptr2);
 742     for (i=0; i<3; i++) {
 743         if (!rb_equal(ptr1[i], ptr2[i]))
 744             return Qfalse;
 745     }
 746     return Qtrue;
 747 }
 748
 749 /* :nodoc: */
 750 static VALUE
 751 name_err_mesg_to_str(VALUE obj)
 752 {
 753     VALUE *ptr, mesg;
 754     Data_Get_Struct(obj, VALUE, ptr);
 755
 756     mesg = ptr[0];
 757     if (NIL_P(mesg)) return Qnil;
 758     else {
 759         const char *desc = 0;
 760         VALUE d = 0, args[3];
 761
 762         obj = ptr[1];
 763         switch (TYPE(obj)) {
 764           case T_NIL:
 765             desc = "nil";
 766             break;
 767           case T_TRUE:
 768             desc = "true";
 769             break;
 770           case T_FALSE:
 771             desc = "false";
 772             break;
 773           default:
 774             d = rb_protect(rb_inspect, obj, 0);
 775             if (NIL_P(d) || RSTRING_LEN(d) > 65) {
 776                 d = rb_any_to_s(obj);
 777             }
 778             desc = RSTRING_PTR(d);
 779             break;
 780         }
 781         if (desc && desc[0] != '#') {
 782             d = rb_str_new2(desc);
 783             rb_str_cat2(d, ":");
 784             rb_str_cat2(d, rb_obj_classname(obj));
 785         }
 786         args[0] = mesg;
 787         args[1] = ptr[2];
 788         args[2] = d;
 789         mesg = rb_f_sprintf(3, args);
 790     }
 791     if (OBJ_TAINTED(obj)) OBJ_TAINT(mesg);
 792     return mesg;
 793 }
 794
 795 /* :nodoc: */
 796 static VALUE
 797 name_err_mesg_load(VALUE klass, VALUE str)
 798 {
 799     return str;
 800 }
 801
 802 /*
 803  * call-seq:
 804  *   no_method_error.args  => obj
 805  *
 806  * Return the arguments passed in as the third parameter to
 807  * the constructor.
 808  */
 809
 810 static VALUE
 811 nometh_err_args(VALUE self)
 812 {
 813     return rb_attr_get(self, rb_intern("args"));
 814 }
 815
 816 void
 817 rb_invalid_str(const char *str, const char *type)
 818 {
 819     VALUE s = rb_str_inspect(rb_str_new2(str));
 820
 821     rb_raise(rb_eArgError, "invalid value for %s: %s", type, RSTRING_PTR(s));
 822 }
 823
 824 /*
 825  *  Document-module: Errno
 826  *
 827  *  Ruby exception objects are subclasses of <code>Exception</code>.
 828  *  However, operating systems typically report errors using plain
 829  *  integers. Module <code>Errno</code> is created dynamically to map
 830  *  these operating system errors to Ruby classes, with each error
 831  *  number generating its own subclass of <code>SystemCallError</code>.
 832  *  As the subclass is created in module <code>Errno</code>, its name
 833  *  will start <code>Errno::</code>.
 834  *
 835  *  The names of the <code>Errno::</code> classes depend on
 836  *  the environment in which Ruby runs. On a typical Unix or Windows
 837  *  platform, there are <code>Errno</code> classes such as
 838  *  <code>Errno::EACCES</code>, <code>Errno::EAGAIN</code>,
 839  *  <code>Errno::EINTR</code>, and so on.
 840  *
 841  *  The integer operating system error number corresponding to a
 842  *  particular error is available as the class constant
 843  *  <code>Errno::</code><em>error</em><code>::Errno</code>.
 844  *
 845  *     Errno::EACCES::Errno   #=> 13
 846  *     Errno::EAGAIN::Errno   #=> 11
 847  *     Errno::EINTR::Errno    #=> 4
 848  *
 849  *  The full list of operating system errors on your particular platform
 850  *  are available as the constants of <code>Errno</code>.
 851  *
 852  *     Errno.constants   #=> :E2BIG, :EACCES, :EADDRINUSE, :EADDRNOTAVAIL, ...
 853  */
 854
 855 static st_table *syserr_tbl;
 856
 857 static VALUE
 858 set_syserr(int n, const char *name)
 859 {
 860     VALUE error;
 861
 862     if (!st_lookup(syserr_tbl, n, &error)) {
 863         error = rb_define_class_under(rb_mErrno, name, rb_eSystemCallError);
 864         rb_define_const(error, "Errno", INT2NUM(n));
 865         st_add_direct(syserr_tbl, n, error);
 866     }
 867     else {
 868         rb_define_const(rb_mErrno, name, error);
 869     }
 870     return error;
 871 }
 872
 873 static VALUE
 874 get_syserr(int n)
 875 {
 876     VALUE error;
 877
 878     if (!st_lookup(syserr_tbl, n, &error)) {
 879         char name[8];   /* some Windows' errno have 5 digits. */
 880
 881         snprintf(name, sizeof(name), "E%03d", n);
 882         error = set_syserr(n, name);
 883     }
 884     return error;
 885 }
 886
 887 /*
 888  * call-seq:
 889  *   SystemCallError.new(msg, errno)  => system_call_error_subclass
 890  *
 891  * If _errno_ corresponds to a known system error code, constructs
 892  * the appropriate <code>Errno</code> class for that error, otherwise
 893  * constructs a generic <code>SystemCallError</code> object. The
 894  * error number is subsequently available via the <code>errno</code>
 895  * method.
 896  */
 897
 898 static VALUE
 899 syserr_initialize(int argc, VALUE *argv, VALUE self)
 900 {
 901 #if !defined(_WIN32) && !defined(__VMS)
 902     char *strerror();
 903 #endif
 904     const char *err;
 905     VALUE mesg, error;
 906     VALUE klass = rb_obj_class(self);
 907
 908     if (klass == rb_eSystemCallError) {
 909         rb_scan_args(argc, argv, "11", &mesg, &error);
 910         if (argc == 1 && FIXNUM_P(mesg)) {
 911             error = mesg; mesg = Qnil;
 912         }
 913         if (!NIL_P(error) && st_lookup(syserr_tbl, NUM2LONG(error), &klass)) {
 914             /* change class */
 915             if (TYPE(self) != T_OBJECT) { /* insurance to avoid type crash */
 916                 rb_raise(rb_eTypeError, "invalid instance type");
 917             }
 918             RBASIC(self)->klass = klass;
 919         }
 920     }
 921     else {
 922         rb_scan_args(argc, argv, "01", &mesg);
 923         error = rb_const_get(klass, rb_intern("Errno"));
 924     }
 925     if (!NIL_P(error)) err = strerror(NUM2LONG(error));
 926     else err = "unknown error";
 927     if (!NIL_P(mesg)) {
 928         VALUE str = mesg;
 929
 930         StringValue(str);
 931         mesg = rb_sprintf("%s - %.*s", err,
 932                           (int)RSTRING_LEN(str), RSTRING_PTR(str));
 933     }
 934     else {
 935         mesg = rb_str_new2(err);
 936     }
 937     rb_call_super(1, &mesg);
 938     rb_iv_set(self, "errno", error);
 939     return self;
 940 }
 941
 942 /*
 943  * call-seq:
 944  *   system_call_error.errno   => fixnum
 945  *
 946  * Return this SystemCallError's error number.
 947  */
 948
 949 static VALUE
 950 syserr_errno(VALUE self)
 951 {
 952     return rb_attr_get(self, rb_intern("errno"));
 953 }
 954
 955 /*
 956  * call-seq:
 957  *   system_call_error === other  => true or false
 958  *
 959  * Return +true+ if the receiver is a generic +SystemCallError+, or
 960  * if the error numbers _self_ and _other_ are the same.
 961  */
 962
 963 static VALUE
 964 syserr_eqq(VALUE self, VALUE exc)
 965 {
 966     VALUE num, e;
 967     ID en;
 968
 969     CONST_ID(en, "errno");
 970
 971     if (!rb_obj_is_kind_of(exc, rb_eSystemCallError)) {
 972         if (!rb_respond_to(exc, en)) return Qfalse;
 973     }
 974     else if (self == rb_eSystemCallError) return Qtrue;
 975
 976     num = rb_attr_get(exc, rb_intern("errno"));
 977     if (NIL_P(num)) {
 978         num = rb_funcall(exc, en, 0, 0);
 979     }
 980     e = rb_const_get(self, rb_intern("Errno"));
 981     if (FIXNUM_P(num) ? num == e : rb_equal(num, e))
 982         return Qtrue;
 983     return Qfalse;
 984 }
 985
 986 /*
 987  * call-seq:
 988  *   Errno.const_missing   => SystemCallError
 989  *
 990  * Returns default SystemCallError class.
 991  */
 992 static VALUE
 993 errno_missing(VALUE self, VALUE id)
 994 {
 995     return rb_eNOERROR;
 996 }
 997
 998 /*
 999  *  Descendants of class <code>Exception</code> are used to communicate
1000  *  between <code>raise</code> methods and <code>rescue</code>
1001  *  statements in <code>begin/end</code> blocks. <code>Exception</code>
1002  *  objects carry information about the exception---its type (the
1003  *  exception's class name), an optional descriptive string, and
1004  *  optional traceback information. Programs may subclass
1005  *  <code>Exception</code> to add additional information.
1006  */
1007
1008 void
1009 Init_Exception(void)
1010 {
1011     rb_eException   = rb_define_class("Exception", rb_cObject);
1012     rb_define_singleton_method(rb_eException, "exception", rb_class_new_instance, -1);
1013     rb_define_method(rb_eException, "exception", exc_exception, -1);
1014     rb_define_method(rb_eException, "initialize", exc_initialize, -1);
1015     rb_define_method(rb_eException, "==", exc_equal, 1);
1016     rb_define_method(rb_eException, "to_s", exc_to_s, 0);
1017     rb_define_method(rb_eException, "message", exc_message, 0);
1018     rb_define_method(rb_eException, "inspect", exc_inspect, 0);
1019     rb_define_method(rb_eException, "backtrace", exc_backtrace, 0);
1020     rb_define_method(rb_eException, "set_backtrace", exc_set_backtrace, 1);
1021
1022     rb_eSystemExit  = rb_define_class("SystemExit", rb_eException);
1023     rb_define_method(rb_eSystemExit, "initialize", exit_initialize, -1);
1024     rb_define_method(rb_eSystemExit, "status", exit_status, 0);
1025     rb_define_method(rb_eSystemExit, "success?", exit_success_p, 0);
1026
1027     rb_eFatal       = rb_define_class("fatal", rb_eException);
1028     rb_eSignal      = rb_define_class("SignalException", rb_eException);
1029     rb_eInterrupt   = rb_define_class("Interrupt", rb_eSignal);
1030
1031     rb_eStandardError = rb_define_class("StandardError", rb_eException);
1032     rb_eTypeError     = rb_define_class("TypeError", rb_eStandardError);
1033     rb_eArgError      = rb_define_class("ArgumentError", rb_eStandardError);
1034     rb_eIndexError    = rb_define_class("IndexError", rb_eStandardError);
1035     rb_eKeyError      = rb_define_class("KeyError", rb_eIndexError);
1036     rb_eRangeError    = rb_define_class("RangeError", rb_eStandardError);
1037
1038     rb_eScriptError = rb_define_class("ScriptError", rb_eException);
1039     rb_eSyntaxError = rb_define_class("SyntaxError", rb_eScriptError);
1040     rb_eLoadError   = rb_define_class("LoadError", rb_eScriptError);
1041     rb_eNotImpError = rb_define_class("NotImplementedError", rb_eScriptError);
1042
1043     rb_eNameError     = rb_define_class("NameError", rb_eStandardError);
1044     rb_define_method(rb_eNameError, "initialize", name_err_initialize, -1);
1045     rb_define_method(rb_eNameError, "name", name_err_name, 0);
1046     rb_define_method(rb_eNameError, "to_s", name_err_to_s, 0);
1047     rb_cNameErrorMesg = rb_define_class_under(rb_eNameError, "message", rb_cData);
1048     rb_define_singleton_method(rb_cNameErrorMesg, "!", name_err_mesg_new, 3);
1049     rb_define_method(rb_cNameErrorMesg, "==", name_err_mesg_equal, 1);
1050     rb_define_method(rb_cNameErrorMesg, "to_str", name_err_mesg_to_str, 0);
1051     rb_define_method(rb_cNameErrorMesg, "_dump", name_err_mesg_to_str, 1);
1052     rb_define_singleton_method(rb_cNameErrorMesg, "_load", name_err_mesg_load, 1);
1053     rb_eNoMethodError = rb_define_class("NoMethodError", rb_eNameError);
1054     rb_define_method(rb_eNoMethodError, "initialize", nometh_err_initialize, -1);
1055     rb_define_method(rb_eNoMethodError, "args", nometh_err_args, 0);
1056
1057     rb_eRuntimeError = rb_define_class("RuntimeError", rb_eStandardError);
1058     rb_eSecurityError = rb_define_class("SecurityError", rb_eException);
1059     rb_eNoMemError = rb_define_class("NoMemoryError", rb_eException);
1060
1061     syserr_tbl = st_init_numtable();
1062     rb_eSystemCallError = rb_define_class("SystemCallError", rb_eStandardError);
1063     rb_define_method(rb_eSystemCallError, "initialize", syserr_initialize, -1);
1064     rb_define_method(rb_eSystemCallError, "errno", syserr_errno, 0);
1065     rb_define_singleton_method(rb_eSystemCallError, "===", syserr_eqq, 1);
1066
1067     rb_mErrno = rb_define_module("Errno");
1068     rb_define_singleton_method(rb_mErrno, "const_missing", errno_missing, 1);
1069
1070     rb_define_global_function("warn", rb_warn_m, 1);
1071 }
1072
1073 void
1074 rb_raise(VALUE exc, const char *fmt, ...)
1075 {
1076     va_list args;
1077     char buf[BUFSIZ];
1078
1079     va_start(args,fmt);
1080     vsnprintf(buf, BUFSIZ, fmt, args);
1081     va_end(args);
1082     rb_exc_raise(rb_exc_new2(exc, buf));
1083 }
1084
1085 void
1086 rb_loaderror(const char *fmt, ...)
1087 {
1088     va_list args;
1089     char buf[BUFSIZ];
1090
1091     va_start(args, fmt);
1092     vsnprintf(buf, BUFSIZ, fmt, args);
1093     va_end(args);
1094     rb_exc_raise(rb_exc_new2(rb_eLoadError, buf));
1095 }
1096
1097 void
1098 rb_notimplement(void)
1099 {
1100     rb_raise(rb_eNotImpError,
1101              "%s() function is unimplemented on this machine",
1102              rb_id2name(rb_frame_this_func()));
1103 }
1104
1105 void
1106 rb_fatal(const char *fmt, ...)
1107 {
1108     va_list args;
1109     char buf[BUFSIZ];
1110
1111     va_start(args, fmt);
1112     vsnprintf(buf, BUFSIZ, fmt, args);
1113     va_end(args);
1114
1115     rb_exc_fatal(rb_exc_new2(rb_eFatal, buf));
1116 }
1117
1118 void
1119 rb_sys_fail(const char *mesg)
1120 {
1121     int n = errno;
1122     VALUE arg;
1123
1124     errno = 0;
1125     if (n == 0) {
1126         rb_bug("rb_sys_fail(%s) - errno == 0", mesg ? mesg : "");
1127     }
1128
1129     arg = mesg ? rb_str_new2(mesg) : Qnil;
1130     rb_exc_raise(rb_class_new_instance(1, &arg, get_syserr(n)));
1131 }
1132
1133 void
1134 rb_sys_warning(const char *fmt, ...)
1135 {
1136     char buf[BUFSIZ];
1137     va_list args;
1138     int errno_save;
1139
1140     errno_save = errno;
1141
1142     if (!RTEST(ruby_verbose)) return;
1143
1144     snprintf(buf, BUFSIZ, "warning: %s", fmt);
1145     snprintf(buf+strlen(buf), BUFSIZ-strlen(buf), ": %s", strerror(errno_save));
1146
1147     va_start(args, fmt);
1148     warn_print(buf, args);
1149     va_end(args);
1150     errno = errno_save;
1151 }
1152
1153 void
1154 rb_load_fail(const char *path)
1155 {
1156     rb_loaderror("%s -- %s", strerror(errno), path);
1157 }
1158
1159 void
1160 rb_error_frozen(const char *what)
1161 {
1162     rb_raise(rb_eRuntimeError, "can't modify frozen %s", what);
1163 }
1164
1165 void
1166 rb_check_frozen(VALUE obj)
1167 {
1168     if (OBJ_FROZEN(obj)) rb_error_frozen(rb_obj_classname(obj));
1169 }
1170
1171 void
1172 Init_syserr(void)
1173 {
1174 #ifdef EPERM
1175     set_syserr(EPERM, "EPERM");
1176 #endif
1177 #ifdef ENOENT
1178     set_syserr(ENOENT, "ENOENT");
1179 #endif
1180 #ifdef ESRCH
1181     set_syserr(ESRCH, "ESRCH");
1182 #endif
1183 #ifdef EINTR
1184     set_syserr(EINTR, "EINTR");
1185 #endif
1186 #ifdef EIO
1187     set_syserr(EIO, "EIO");
1188 #endif
1189 #ifdef ENXIO
1190     set_syserr(ENXIO, "ENXIO");
1191 #endif
1192 #ifdef E2BIG
1193     set_syserr(E2BIG, "E2BIG");
1194 #endif
1195 #ifdef ENOEXEC
1196     set_syserr(ENOEXEC, "ENOEXEC");
1197 #endif
1198 #ifdef EBADF
1199     set_syserr(EBADF, "EBADF");
1200 #endif
1201 #ifdef ECHILD
1202     set_syserr(ECHILD, "ECHILD");
1203 #endif
1204 #ifdef EAGAIN
1205     set_syserr(EAGAIN, "EAGAIN");
1206 #endif
1207 #ifdef ENOMEM
1208     set_syserr(ENOMEM, "ENOMEM");
1209 #endif
1210 #ifdef EACCES
1211     set_syserr(EACCES, "EACCES");
1212 #endif
1213 #ifdef EFAULT
1214     set_syserr(EFAULT, "EFAULT");
1215 #endif
1216 #ifdef ENOTBLK
1217     set_syserr(ENOTBLK, "ENOTBLK");
1218 #endif
1219 #ifdef EBUSY
1220     set_syserr(EBUSY, "EBUSY");
1221 #endif
1222 #ifdef EEXIST
1223     set_syserr(EEXIST, "EEXIST");
1224 #endif
1225 #ifdef EXDEV
1226     set_syserr(EXDEV, "EXDEV");
1227 #endif
1228 #ifdef ENODEV
1229     set_syserr(ENODEV, "ENODEV");
1230 #endif
1231 #ifdef ENOTDIR
1232     set_syserr(ENOTDIR, "ENOTDIR");
1233 #endif
1234 #ifdef EISDIR
1235     set_syserr(EISDIR, "EISDIR");
1236 #endif
1237 #ifdef EINVAL
1238     set_syserr(EINVAL, "EINVAL");
1239 #endif
1240 #ifdef ENFILE
1241     set_syserr(ENFILE, "ENFILE");
1242 #endif
1243 #ifdef EMFILE
1244     set_syserr(EMFILE, "EMFILE");
1245 #endif
1246 #ifdef ENOTTY
1247     set_syserr(ENOTTY, "ENOTTY");
1248 #endif
1249 #ifdef ETXTBSY
1250     set_syserr(ETXTBSY, "ETXTBSY");
1251 #endif
1252 #ifdef EFBIG
1253     set_syserr(EFBIG, "EFBIG");
1254 #endif
1255 #ifdef ENOSPC
1256     set_syserr(ENOSPC, "ENOSPC");
1257 #endif
1258 #ifdef ESPIPE
1259     set_syserr(ESPIPE, "ESPIPE");
1260 #endif
1261 #ifdef EROFS
1262     set_syserr(EROFS, "EROFS");
1263 #endif
1264 #ifdef EMLINK
1265     set_syserr(EMLINK, "EMLINK");
1266 #endif
1267 #ifdef EPIPE
1268     set_syserr(EPIPE, "EPIPE");
1269 #endif
1270 #ifdef EDOM
1271     set_syserr(EDOM, "EDOM");
1272 #endif
1273 #ifdef ERANGE
1274     set_syserr(ERANGE, "ERANGE");
1275 #endif
1276 #ifdef EDEADLK
1277     set_syserr(EDEADLK, "EDEADLK");
1278 #endif
1279 #ifdef ENAMETOOLONG
1280     set_syserr(ENAMETOOLONG, "ENAMETOOLONG");
1281 #endif
1282 #ifdef ENOLCK
1283     set_syserr(ENOLCK, "ENOLCK");
1284 #endif
1285 #ifdef ENOSYS
1286     set_syserr(ENOSYS, "ENOSYS");
1287 #endif
1288 #ifdef ENOTEMPTY
1289     set_syserr(ENOTEMPTY, "ENOTEMPTY");
1290 #endif
1291 #ifdef ELOOP
1292     set_syserr(ELOOP, "ELOOP");
1293 #endif
1294 #ifdef EWOULDBLOCK
1295     set_syserr(EWOULDBLOCK, "EWOULDBLOCK");
1296 #endif
1297 #ifdef ENOMSG
1298     set_syserr(ENOMSG, "ENOMSG");
1299 #endif
1300 #ifdef EIDRM
1301     set_syserr(EIDRM, "EIDRM");
1302 #endif
1303 #ifdef ECHRNG
1304     set_syserr(ECHRNG, "ECHRNG");
1305 #endif
1306 #ifdef EL2NSYNC
1307     set_syserr(EL2NSYNC, "EL2NSYNC");
1308 #endif
1309 #ifdef EL3HLT
1310     set_syserr(EL3HLT, "EL3HLT");
1311 #endif
1312 #ifdef EL3RST
1313     set_syserr(EL3RST, "EL3RST");
1314 #endif
1315 #ifdef ELNRNG
1316     set_syserr(ELNRNG, "ELNRNG");
1317 #endif
1318 #ifdef EUNATCH
1319     set_syserr(EUNATCH, "EUNATCH");
1320 #endif
1321 #ifdef ENOCSI
1322     set_syserr(ENOCSI, "ENOCSI");
1323 #endif
1324 #ifdef EL2HLT
1325     set_syserr(EL2HLT, "EL2HLT");
1326 #endif
1327 #ifdef EBADE
1328     set_syserr(EBADE, "EBADE");
1329 #endif
1330 #ifdef EBADR
1331     set_syserr(EBADR, "EBADR");
1332 #endif
1333 #ifdef EXFULL
1334     set_syserr(EXFULL, "EXFULL");
1335 #endif
1336 #ifdef ENOANO
1337     set_syserr(ENOANO, "ENOANO");
1338 #endif
1339 #ifdef EBADRQC
1340     set_syserr(EBADRQC, "EBADRQC");
1341 #endif
1342 #ifdef EBADSLT
1343     set_syserr(EBADSLT, "EBADSLT");
1344 #endif
1345 #ifdef EDEADLOCK
1346     set_syserr(EDEADLOCK, "EDEADLOCK");
1347 #endif
1348 #ifdef EBFONT
1349     set_syserr(EBFONT, "EBFONT");
1350 #endif
1351 #ifdef ENOSTR
1352     set_syserr(ENOSTR, "ENOSTR");
1353 #endif
1354 #ifdef ENODATA
1355     set_syserr(ENODATA, "ENODATA");
1356 #endif
1357 #ifdef ETIME
1358     set_syserr(ETIME, "ETIME");
1359 #endif
1360 #ifdef ENOSR
1361     set_syserr(ENOSR, "ENOSR");
1362 #endif
1363 #ifdef ENONET
1364     set_syserr(ENONET, "ENONET");
1365 #endif
1366 #ifdef ENOPKG
1367     set_syserr(ENOPKG, "ENOPKG");
1368 #endif
1369 #ifdef EREMOTE
1370     set_syserr(EREMOTE, "EREMOTE");
1371 #endif
1372 #ifdef ENOLINK
1373     set_syserr(ENOLINK, "ENOLINK");
1374 #endif
1375 #ifdef EADV
1376     set_syserr(EADV, "EADV");
1377 #endif
1378 #ifdef ESRMNT
1379     set_syserr(ESRMNT, "ESRMNT");
1380 #endif
1381 #ifdef ECOMM
1382     set_syserr(ECOMM, "ECOMM");
1383 #endif
1384 #ifdef EPROTO
1385     set_syserr(EPROTO, "EPROTO");
1386 #endif
1387 #ifdef EMULTIHOP
1388     set_syserr(EMULTIHOP, "EMULTIHOP");
1389 #endif
1390 #ifdef EDOTDOT
1391     set_syserr(EDOTDOT, "EDOTDOT");
1392 #endif
1393 #ifdef EBADMSG
1394     set_syserr(EBADMSG, "EBADMSG");
1395 #endif
1396 #ifdef EOVERFLOW
1397     set_syserr(EOVERFLOW, "EOVERFLOW");
1398 #endif
1399 #ifdef ENOTUNIQ
1400     set_syserr(ENOTUNIQ, "ENOTUNIQ");
1401 #endif
1402 #ifdef EBADFD
1403     set_syserr(EBADFD, "EBADFD");
1404 #endif
1405 #ifdef EREMCHG
1406     set_syserr(EREMCHG, "EREMCHG");
1407 #endif
1408 #ifdef ELIBACC
1409     set_syserr(ELIBACC, "ELIBACC");
1410 #endif
1411 #ifdef ELIBBAD
1412     set_syserr(ELIBBAD, "ELIBBAD");
1413 #endif
1414 #ifdef ELIBSCN
1415     set_syserr(ELIBSCN, "ELIBSCN");
1416 #endif
1417 #ifdef ELIBMAX
1418     set_syserr(ELIBMAX, "ELIBMAX");
1419 #endif
1420 #ifdef ELIBEXEC
1421     set_syserr(ELIBEXEC, "ELIBEXEC");
1422 #endif
1423 #ifdef EILSEQ
1424     set_syserr(EILSEQ, "EILSEQ");
1425 #endif
1426 #ifdef ERESTART
1427     set_syserr(ERESTART, "ERESTART");
1428 #endif
1429 #ifdef ESTRPIPE
1430     set_syserr(ESTRPIPE, "ESTRPIPE");
1431 #endif
1432 #ifdef EUSERS
1433     set_syserr(EUSERS, "EUSERS");
1434 #endif
1435 #ifdef ENOTSOCK
1436     set_syserr(ENOTSOCK, "ENOTSOCK");
1437 #endif
1438 #ifdef EDESTADDRREQ
1439     set_syserr(EDESTADDRREQ, "EDESTADDRREQ");
1440 #endif
1441 #ifdef EMSGSIZE
1442     set_syserr(EMSGSIZE, "EMSGSIZE");
1443 #endif
1444 #ifdef EPROTOTYPE
1445     set_syserr(EPROTOTYPE, "EPROTOTYPE");
1446 #endif
1447 #ifdef ENOPROTOOPT
1448     set_syserr(ENOPROTOOPT, "ENOPROTOOPT");
1449 #endif
1450 #ifdef EPROTONOSUPPORT
1451     set_syserr(EPROTONOSUPPORT, "EPROTONOSUPPORT");
1452 #endif
1453 #ifdef ESOCKTNOSUPPORT
1454     set_syserr(ESOCKTNOSUPPORT, "ESOCKTNOSUPPORT");
1455 #endif
1456 #ifdef EOPNOTSUPP
1457     set_syserr(EOPNOTSUPP, "EOPNOTSUPP");
1458 #endif
1459 #ifdef EPFNOSUPPORT
1460     set_syserr(EPFNOSUPPORT, "EPFNOSUPPORT");
1461 #endif
1462 #ifdef EAFNOSUPPORT
1463     set_syserr(EAFNOSUPPORT, "EAFNOSUPPORT");
1464 #endif
1465 #ifdef EADDRINUSE
1466     set_syserr(EADDRINUSE, "EADDRINUSE");
1467 #endif
1468 #ifdef EADDRNOTAVAIL
1469     set_syserr(EADDRNOTAVAIL, "EADDRNOTAVAIL");
1470 #endif
1471 #ifdef ENETDOWN
1472     set_syserr(ENETDOWN, "ENETDOWN");
1473 #endif
1474 #ifdef ENETUNREACH
1475     set_syserr(ENETUNREACH, "ENETUNREACH");
1476 #endif
1477 #ifdef ENETRESET
1478     set_syserr(ENETRESET, "ENETRESET");
1479 #endif
1480 #ifdef ECONNABORTED
1481     set_syserr(ECONNABORTED, "ECONNABORTED");
1482 #endif
1483 #ifdef ECONNRESET
1484     set_syserr(ECONNRESET, "ECONNRESET");
1485 #endif
1486 #ifdef ENOBUFS
1487     set_syserr(ENOBUFS, "ENOBUFS");
1488 #endif
1489 #ifdef EISCONN
1490     set_syserr(EISCONN, "EISCONN");
1491 #endif
1492 #ifdef ENOTCONN
1493     set_syserr(ENOTCONN, "ENOTCONN");
1494 #endif
1495 #ifdef ESHUTDOWN
1496     set_syserr(ESHUTDOWN, "ESHUTDOWN");
1497 #endif
1498 #ifdef ETOOMANYREFS
1499     set_syserr(ETOOMANYREFS, "ETOOMANYREFS");
1500 #endif
1501 #ifdef ETIMEDOUT
1502     set_syserr(ETIMEDOUT, "ETIMEDOUT");
1503 #endif
1504 #ifdef ECONNREFUSED
1505     set_syserr(ECONNREFUSED, "ECONNREFUSED");
1506 #endif
1507 #ifdef EHOSTDOWN
1508     set_syserr(EHOSTDOWN, "EHOSTDOWN");
1509 #endif
1510 #ifdef EHOSTUNREACH
1511     set_syserr(EHOSTUNREACH, "EHOSTUNREACH");
1512 #endif
1513 #ifdef EALREADY
1514     set_syserr(EALREADY, "EALREADY");
1515 #endif
1516 #ifdef EINPROGRESS
1517     set_syserr(EINPROGRESS, "EINPROGRESS");
1518 #endif
1519 #ifdef ESTALE
1520     set_syserr(ESTALE, "ESTALE");
1521 #endif
1522 #ifdef EUCLEAN
1523     set_syserr(EUCLEAN, "EUCLEAN");
1524 #endif
1525 #ifdef ENOTNAM
1526     set_syserr(ENOTNAM, "ENOTNAM");
1527 #endif
1528 #ifdef ENAVAIL
1529     set_syserr(ENAVAIL, "ENAVAIL");
1530 #endif
1531 #ifdef EISNAM
1532     set_syserr(EISNAM, "EISNAM");
1533 #endif
1534 #ifdef EREMOTEIO
1535     set_syserr(EREMOTEIO, "EREMOTEIO");
1536 #endif
1537 #ifdef EDQUOT
1538     set_syserr(EDQUOT, "EDQUOT");
1539 #endif
1540     rb_eNOERROR = set_syserr(0, "NOERROR");
1541 }
1542
1543 static void
1544 err_append(const char *s)
1545 {
1546     rb_thread_t *th = GET_THREAD();
1547     VALUE err = th->errinfo;
1548
1549     if (th->mild_compile_error) {
1550         if (!RTEST(err)) {
1551             err = rb_exc_new2(rb_eSyntaxError, s);
1552             th->errinfo = err;
1553         }
1554         else {
1555             VALUE str = rb_obj_as_string(err);
1556
1557             rb_str_cat2(str, "\n");
1558             rb_str_cat2(str, s);
1559             th->errinfo = rb_exc_new3(rb_eSyntaxError, str);
1560         }
1561     }
1562     else {
1563         if (!RTEST(err)) {
1564             err = rb_exc_new2(rb_eSyntaxError, "compile error");
1565             th->errinfo = err;
1566         }
1567         rb_write_error(s);
1568         rb_write_error("\n");
1569     }
1570 }