/**********************************************************************

error.c -

$Author$

$Date$

created at: Mon Aug 9 16:11:34 JST 1993

Copyright (C) 1993-2003 Yukihiro Matsumoto

**********************************************************************/

#include "ruby.h"

#include "env.h"

#include "st.h"

#include <stdio.h>

#ifdef HAVE_STDARG_PROTOTYPES

#include <stdarg.h>

#define va_init_list(a,b) va_start(a,b)

#else

#include <varargs.h>

#define va_init_list(a,b) va_start(a)

#endif

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#ifndef EXIT_SUCCESS

#define EXIT_SUCCESS 0

#endif

extern const char *ruby_description;

int ruby_nerrs;

static int

err_position(buf, len)

char *buf;

long len;

{

ruby_set_current_source();

if (!ruby_sourcefile) {

return 0;

}

else if (ruby_sourceline == 0) {

return snprintf(buf, len, "%s: ", ruby_sourcefile);

}

else {

return snprintf(buf, len, "%s:%d: ", ruby_sourcefile, ruby_sourceline);

}

}

static void

err_snprintf(buf, len, fmt, args)

char *buf;

long len;

const char *fmt;

va_list args;

{

long n;

n = err_position(buf, len);

if (len > n) {

vsnprintf((char*)buf+n, len-n, fmt, args);

}

}

static void err_append _((const char*));

static void

err_print(fmt, args)

const char *fmt;

va_list args;

{

char buf[BUFSIZ];

err_snprintf(buf, BUFSIZ, fmt, args);

err_append(buf);

}

void

#ifdef HAVE_STDARG_PROTOTYPES

rb_compile_error(const char *fmt, ...)

#else

rb_compile_error(fmt, va_alist)

const char *fmt;

va_dcl

#endif

{

va_list args;

va_init_list(args, fmt);

err_print(fmt, args);

va_end(args);

ruby_nerrs++;

}

void

#ifdef HAVE_STDARG_PROTOTYPES

rb_compile_error_append(const char *fmt, ...)

#else

rb_compile_error_append(fmt, va_alist)

const char *fmt;

va_dcl

#endif

{

va_list args;

char buf[BUFSIZ];

va_init_list(args, fmt);

vsnprintf(buf, BUFSIZ, fmt, args);

va_end(args);

err_append(buf);

}

static void

warn_print(fmt, args)

const char *fmt;

va_list args;

{

char buf[BUFSIZ];

int len;

err_snprintf(buf, BUFSIZ, fmt, args);

len = strlen(buf);

buf[len++] = '\n';

rb_write_error2(buf, len);

}

void

#ifdef HAVE_STDARG_PROTOTYPES

rb_warn(const char *fmt, ...)

#else

rb_warn(fmt, va_alist)

const char *fmt;

va_dcl

#endif

{

char buf[BUFSIZ];

va_list args;

if (NIL_P(ruby_verbose)) return;

snprintf(buf, BUFSIZ, "warning: %s", fmt);

va_init_list(args, fmt);

warn_print(buf, args);

va_end(args);

}

/* rb_warning() reports only in verbose mode */

void

#ifdef HAVE_STDARG_PROTOTYPES

rb_warning(const char *fmt, ...)

#else

rb_warning(fmt, va_alist)

const char *fmt;

va_dcl

#endif

{

char buf[BUFSIZ];

va_list args;

if (!RTEST(ruby_verbose)) return;

snprintf(buf, BUFSIZ, "warning: %s", fmt);

va_init_list(args, fmt);

warn_print(buf, args);

va_end(args);

}

/*

* call-seq:

* warn(msg) => nil

*

* Display the given message (followed by a newline) on STDERR unless

* warnings are disabled (for example with the <code>-W0</code> flag).

*/

static VALUE

rb_warn_m(self, mesg)

VALUE self, mesg;

{

if (!NIL_P(ruby_verbose)) {

rb_io_write(rb_stderr, mesg);

rb_io_write(rb_stderr, rb_default_rs);

}

return Qnil;

}

void

#ifdef HAVE_STDARG_PROTOTYPES

rb_bug(const char *fmt, ...)

#else

rb_bug(fmt, va_alist)

const char *fmt;

va_dcl

#endif

{

char buf[BUFSIZ];

va_list args;

FILE *out = stderr;

int len = err_position(buf, BUFSIZ);

if (fwrite(buf, 1, len, out) == len ||

fwrite(buf, 1, len, (out = stdout)) == len) {

fputs("[BUG] ", out);

va_init_list(args, fmt);

vfprintf(out, fmt, args);

va_end(args);

fprintf(out, "\n%s\n\n", ruby_description);

}

abort();

}

static struct types {

int type;

const char *name;

} builtin_types[] = {

{T_NIL, "nil"},

{T_OBJECT, "Object"},

{T_CLASS, "Class"},

{T_ICLASS, "iClass"}, /* internal use: mixed-in module holder */

{T_MODULE, "Module"},

{T_FLOAT, "Float"},

{T_STRING, "String"},

{T_REGEXP, "Regexp"},

{T_ARRAY, "Array"},

{T_FIXNUM, "Fixnum"},

{T_HASH, "Hash"},

{T_STRUCT, "Struct"},

{T_BIGNUM, "Bignum"},

{T_FILE, "File"},

{T_TRUE, "true"},

{T_FALSE, "false"},

{T_SYMBOL, "Symbol"}, /* :symbol */

{T_DATA, "Data"}, /* internal use: wrapped C pointers */

{T_MATCH, "MatchData"}, /* data of $~ */

{T_VARMAP, "Varmap"}, /* internal use: dynamic variables */

{T_SCOPE, "Scope"}, /* internal use: variable scope */

{T_NODE, "Node"}, /* internal use: syntax tree node */

{T_UNDEF, "undef"}, /* internal use: #undef; should not happen */

{-1, 0}

};

void

rb_check_type(x, t)

VALUE x;

int t;

{

struct types *type = builtin_types;

if (x == Qundef) {

rb_bug("undef leaked to the Ruby space");

}

if (TYPE(x) != t) {

while (type->type >= 0) {

if (type->type == t) {

const char *etype;

if (NIL_P(x)) {

etype = "nil";

}

else if (FIXNUM_P(x)) {

etype = "Fixnum";

}

else if (SYMBOL_P(x)) {

etype = "Symbol";

}

else if (rb_special_const_p(x)) {

etype = RSTRING(rb_obj_as_string(x))->ptr;

}

else {

etype = rb_obj_classname(x);

}

rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)",

etype, type->name);

}

type++;

}

rb_bug("unknown type 0x%x", t);

}

}

/* exception classes */

#include <errno.h>

VALUE rb_eException;

VALUE rb_eSystemExit;

VALUE rb_eInterrupt;

VALUE rb_eSignal;

VALUE rb_eFatal;

VALUE rb_eStandardError;

VALUE rb_eRuntimeError;

VALUE rb_eTypeError;

VALUE rb_eArgError;

VALUE rb_eIndexError;

VALUE rb_eRangeError;

VALUE rb_eNameError;

VALUE rb_eNoMethodError;

VALUE rb_eSecurityError;

VALUE rb_eNotImpError;

VALUE rb_eNoMemError;

VALUE rb_cNameErrorMesg;

VALUE rb_eScriptError;

VALUE rb_eSyntaxError;

VALUE rb_eLoadError;

VALUE rb_eSystemCallError;

VALUE rb_mErrno;

VALUE

rb_exc_new(etype, ptr, len)

VALUE etype;

const char *ptr;

long len;

{

return rb_funcall(etype, rb_intern("new"), 1, rb_str_new(ptr, len));

}

VALUE

rb_exc_new2(etype, s)

VALUE etype;

const char *s;

{

return rb_exc_new(etype, s, strlen(s));

}

VALUE

rb_exc_new3(etype, str)

VALUE etype, str;

{

StringValue(str);

return rb_funcall(etype, rb_intern("new"), 1, str);

}

/*

* call-seq:

* Exception.new(msg = nil) => exception

*

* Construct a new Exception object, optionally passing in

* a message.

*/

static VALUE

exc_initialize(argc, argv, exc)

int argc;

VALUE *argv;

VALUE exc;

{

VALUE arg;

rb_scan_args(argc, argv, "01", &arg);

rb_iv_set(exc, "mesg", arg);

rb_iv_set(exc, "bt", Qnil);

return exc;

}

/*

* Document-method: exception

*

* call-seq:

* exc.exception(string) -> an_exception or exc

*

* With no argument, or if the argument is the same as the receiver,

* return the receiver. Otherwise, create a new

* exception object of the same class as the receiver, but with a

* message equal to <code>string.to_str</code>.

*

*/

static VALUE

exc_exception(argc, argv, self)

int argc;

VALUE *argv;

VALUE self;

{

VALUE exc;

if (argc == 0) return self;

if (argc == 1 && self == argv[0]) return self;

exc = rb_obj_clone(self);

exc_initialize(argc, argv, exc);

return exc;

}

/*

* call-seq:

* exception.to_s => string

*

* Returns exception's message (or the name of the exception if

* no message is set).

*/

static VALUE

exc_to_s(exc)

VALUE exc;

{

VALUE mesg = rb_attr_get(exc, rb_intern("mesg"));

if (NIL_P(mesg)) return rb_class_name(CLASS_OF(exc));

return mesg;

}

/*

* call-seq:

* exception.message => string

* exception.to_str => string

*

* Returns the result of invoking <code>exception.to_s</code>.

* Normally this returns the exception's message or name. By

* supplying a to_str method, exceptions are agreeing to

* be used where Strings are expected.

*/

static VALUE

exc_to_str(exc)

VALUE exc;

{

return rb_funcall(exc, rb_intern("to_s"), 0, 0);

}

/*

* call-seq:

* exception.inspect => string

*

* Return this exception's class name an message

*/

static VALUE

exc_inspect(exc)

VALUE exc;

{

VALUE str, klass;

klass = CLASS_OF(exc);

exc = rb_obj_as_string(exc);

if (RSTRING(exc)->len == 0) {

return rb_str_dup(rb_class_name(klass));

}

str = rb_str_buf_new2("#<");

klass = rb_class_name(klass);

rb_str_buf_append(str, klass);

rb_str_buf_cat(str, ": ", 2);

rb_str_buf_append(str, exc);

rb_str_buf_cat(str, ">", 1);

return str;

}

/*

* call-seq:

* exception.backtrace => array

*

* Returns any backtrace associated with the exception. The backtrace

* is an array of strings, each containing either ``filename:lineNo: in

* `method''' or ``filename:lineNo.''

*

* def a

* raise "boom"

* end

*

* def b

* a()

* end

*

* begin

* b()

* rescue => detail

* print detail.backtrace.join("\n")

* end

*

* <em>produces:</em>

*

* prog.rb:2:in `a'

* prog.rb:6:in `b'

* prog.rb:10

*/

static VALUE

exc_backtrace(exc)

VALUE exc;

{

static ID bt;

if (!bt) bt = rb_intern("bt");

return rb_attr_get(exc, bt);

}

VALUE

rb_check_backtrace(bt)

VALUE bt;

{

long i;

static const char err[] = "backtrace must be Array of String";

if (!NIL_P(bt)) {

int t = TYPE(bt);

if (t == T_STRING) return rb_ary_new3(1, bt);

if (t != T_ARRAY) {

rb_raise(rb_eTypeError, err);

}

for (i=0;i<RARRAY(bt)->len;i++) {

if (TYPE(RARRAY(bt)->ptr[i]) != T_STRING) {

rb_raise(rb_eTypeError, err);

}

}

}

return bt;

}

/*

* call-seq:

* exc.set_backtrace(array) => array

*

* Sets the backtrace information associated with <i>exc</i>. The

* argument must be an array of <code>String</code> objects in the

* format described in <code>Exception#backtrace</code>.

*

*/

static VALUE

exc_set_backtrace(exc, bt)

VALUE exc;

VALUE bt;

{

return rb_iv_set(exc, "bt", rb_check_backtrace(bt));

}

/*

* call-seq:

* SystemExit.new(status=0) => system_exit

*

* Create a new +SystemExit+ exception with the given status.

*/

static VALUE

exit_initialize(argc, argv, exc)

int argc;

VALUE *argv;

VALUE exc;

{

VALUE status = INT2FIX(EXIT_SUCCESS);

if (argc > 0 && FIXNUM_P(argv[0])) {

status = *argv++;

--argc;

}

rb_call_super(argc, argv);

rb_iv_set(exc, "status", status);

return exc;

}

/*

* call-seq:

* system_exit.status => fixnum

*

* Return the status value associated with this system exit.

*/

static VALUE

exit_status(exc)

VALUE exc;

{

return rb_attr_get(exc, rb_intern("status"));

}

/*

* call-seq:

* system_exit.success? => true or false

*

* Returns +true+ if exiting successful, +false+ if not.

*/

static VALUE

exit_success_p(exc)

VALUE exc;

{

VALUE status = rb_attr_get(exc, rb_intern("status"));

if (NIL_P(status)) return Qtrue;

if (status == INT2FIX(EXIT_SUCCESS)) return Qtrue;

return Qfalse;

}

void

#ifdef HAVE_STDARG_PROTOTYPES

rb_name_error(ID id, const char *fmt, ...)

#else

rb_name_error(id, fmt, va_alist)

ID id;

const char *fmt;

va_dcl

#endif

{

VALUE exc, argv[2];

va_list args;

char buf[BUFSIZ];

va_init_list(args, fmt);

vsnprintf(buf, BUFSIZ, fmt, args);

va_end(args);

argv[0] = rb_str_new2(buf);

argv[1] = ID2SYM(id);

exc = rb_class_new_instance(2, argv, rb_eNameError);

rb_exc_raise(exc);

}

/*

* call-seq:

* NameError.new(msg [, name]) => name_error

*

* Construct a new NameError exception. If given the <i>name</i>

* parameter may subsequently be examined using the <code>NameError.name</code>

* method.

*/

static VALUE

name_err_initialize(argc, argv, self)

int argc;

VALUE *argv;

VALUE self;

{

VALUE name;

name = (argc > 1) ? argv[--argc] : Qnil;

rb_call_super(argc, argv);

rb_iv_set(self, "name", name);

return self;

}

/*

* call-seq:

* name_error.name => string or nil

*

* Return the name associated with this NameError exception.

*/

static VALUE

name_err_name(self)

VALUE self;

{

return rb_attr_get(self, rb_intern("name"));

}

/*

* call-seq:

* name_error.to_s => string

*

* Produce a nicely-formated string representing the +NameError+.

*/

static VALUE

name_err_to_s(exc)

VALUE exc;

{

VALUE mesg = rb_attr_get(exc, rb_intern("mesg")), str = mesg;

if (NIL_P(mesg)) return rb_class_name(CLASS_OF(exc));

StringValue(str);

return str;

}

/*

* call-seq:

* NoMethodError.new(msg, name [, args]) => no_method_error

*

* Construct a NoMethodError exception for a method of the given name

* called with the given arguments. The name may be accessed using

* the <code>#name</code> method on the resulting object, and the

* arguments using the <code>#args</code> method.

*/

static VALUE

nometh_err_initialize(argc, argv, self)

int argc;

VALUE *argv;

VALUE self;

{

VALUE args = (argc > 2) ? argv[--argc] : Qnil;

name_err_initialize(argc, argv, self);

rb_iv_set(self, "args", args);

return self;

}

/* :nodoc: */

static void

name_err_mesg_mark(ptr)

VALUE *ptr;

{

rb_gc_mark_locations(ptr, ptr+3);

}

/* :nodoc: */

static VALUE

name_err_mesg_new(obj, mesg, recv, method)

VALUE obj, mesg, recv, method;

{

VALUE *ptr = ALLOC_N(VALUE, 3);

ptr[0] = mesg;

ptr[1] = recv;

ptr[2] = method;

return Data_Wrap_Struct(rb_cNameErrorMesg, name_err_mesg_mark, -1, ptr);

}

/* :nodoc: */

static VALUE

name_err_mesg_to_str(obj)

VALUE obj;

{

VALUE *ptr, mesg;

Data_Get_Struct(obj, VALUE, ptr);

mesg = ptr[0];

if (NIL_P(mesg)) return Qnil;

else {

const char *desc = 0;

VALUE d = 0, args[3];

obj = ptr[1];

switch (TYPE(obj)) {

case T_NIL:

desc = "nil";

break;

case T_TRUE:

desc = "true";

break;

case T_FALSE:

desc = "false";

break;

default:

d = rb_protect(rb_inspect, obj, 0);

if (NIL_P(d) || RSTRING(d)->len > 65) {

d = rb_any_to_s(obj);

}

desc = RSTRING(d)->ptr;

break;

}

if (desc && desc[0] != '#') {

d = rb_str_new2(desc);

rb_str_cat2(d, ":");

rb_str_cat2(d, rb_obj_classname(obj));

}

args[0] = mesg;

args[1] = ptr[2];

args[2] = d;

mesg = rb_f_sprintf(3, args);

}

if (OBJ_TAINTED(obj)) OBJ_TAINT(mesg);

return mesg;

}

/* :nodoc: */

static VALUE

name_err_mesg_load(klass, str)

VALUE klass, str;

{

return str;

}

/*

* call-seq:

* no_method_error.args => obj

*

* Return the arguments passed in as the third parameter to

* the constructor.

*/

static VALUE

nometh_err_args(self)

VALUE self;

{

return rb_attr_get(self, rb_intern("args"));

}

void

rb_invalid_str(str, type)

const char *str, *type;

{

VALUE s = rb_str_inspect(rb_str_new2(str));

rb_raise(rb_eArgError, "invalid value for %s: %s", type, RSTRING(s)->ptr);

}

/*

* Document-module: Errno

*

* Ruby exception objects are subclasses of <code>Exception</code>.

* However, operating systems typically report errors using plain

* integers. Module <code>Errno</code> is created dynamically to map

* these operating system errors to Ruby classes, with each error

* number generating its own subclass of <code>SystemCallError</code>.

* As the subclass is created in module <code>Errno</code>, its name

* will start <code>Errno::</code>.

*

* The names of the <code>Errno::</code> classes depend on

* the environment in which Ruby runs. On a typical Unix or Windows

* platform, there are <code>Errno</code> classes such as

* <code>Errno::EACCES</code>, <code>Errno::EAGAIN</code>,

* <code>Errno::EINTR</code>, and so on.

*

* The integer operating system error number corresponding to a

* particular error is available as the class constant

* <code>Errno::</code><em>error</em><code>::Errno</code>.

*

* Errno::EACCES::Errno #=> 13

* Errno::EAGAIN::Errno #=> 11

* Errno::EINTR::Errno #=> 4

*

* The full list of operating system errors on your particular platform

* are available as the constants of <code>Errno</code>.

*

* Errno.constants #=> E2BIG, EACCES, EADDRINUSE, EADDRNOTAVAIL, ...

*/

static st_table *syserr_tbl;

static VALUE

set_syserr(n, name)

int n;

const char *name;

{

VALUE error;

if (!st_lookup(syserr_tbl, n, &error)) {

error = rb_define_class_under(rb_mErrno, name, rb_eSystemCallError);

rb_define_const(error, "Errno", INT2NUM(n));

st_add_direct(syserr_tbl, n, error);

}

else {

rb_define_const(rb_mErrno, name, error);

}

return error;

}

static VALUE

get_syserr(n)

int n;

{

VALUE error;

if (!st_lookup(syserr_tbl, n, &error)) {

char name[8]; /* some Windows' errno have 5 digits. */

snprintf(name, sizeof(name), "E%03d", n);

error = set_syserr(n, name);

}

return error;

}

/*

* call-seq:

* SystemCallError.new(msg, errno) => system_call_error_subclass

*

* If _errno_ corresponds to a known system error code, constructs

* the appropriate <code>Errno</code> class for that error, otherwise

* constructs a generic <code>SystemCallError</code> object. The

* error number is subsequently available via the <code>errno</code>

* method.

*/

static VALUE

syserr_initialize(argc, argv, self)

int argc;

VALUE *argv;

VALUE self;

{

#if !defined(_WIN32) && !defined(__VMS)

char *strerror();

#endif

const char *err;

VALUE mesg, error;

VALUE klass = rb_obj_class(self);

if (klass == rb_eSystemCallError) {

rb_scan_args(argc, argv, "11", &mesg, &error);

if (argc == 1 && FIXNUM_P(mesg)) {

error = mesg; mesg = Qnil;

}

if (!NIL_P(error) && st_lookup(syserr_tbl, NUM2LONG(error), &klass)) {

/* change class */

if (TYPE(self) != T_OBJECT) { /* insurance to avoid type crash */

rb_raise(rb_eTypeError, "invalid instance type");

}

RBASIC(self)->klass = klass;

}

}

else {

rb_scan_args(argc, argv, "01", &mesg);

error = rb_const_get(klass, rb_intern("Errno"));

}

if (!NIL_P(error)) err = strerror(NUM2LONG(error));

else err = "unknown error";

if (!NIL_P(mesg)) {

VALUE str = mesg;

size_t len;

StringValue(str);

len = strlen(err)+RSTRING(str)->len+3;

mesg = rb_str_new(0, len);

snprintf(RSTRING(mesg)->ptr, len+1, "%s - %.*s", err,

(int)RSTRING(str)->len, RSTRING(str)->ptr);

rb_str_resize(mesg, strlen(RSTRING(mesg)->ptr));

}

else {

mesg = rb_str_new2(err);

}

rb_call_super(1, &mesg);

rb_iv_set(self, "errno", error);

return self;

}

/*

* call-seq:

* system_call_error.errno => fixnum

*

* Return this SystemCallError's error number.

*/

static VALUE

syserr_errno(self)

VALUE self;

{

return rb_attr_get(self, rb_intern("errno"));

}

/*

* call-seq:

* system_call_error === other => true or false

*

* Return +true+ if the receiver is a generic +SystemCallError+, or

* if the error numbers _self_ and _other_ are the same.

*/

static VALUE

syserr_eqq(self, exc)

VALUE self, exc;

{

VALUE num, e;

ID en = rb_intern("errno");

if (!rb_obj_is_kind_of(exc, rb_eSystemCallError)) {

if (!rb_respond_to(exc, en)) return Qfalse;

}

else if (self == rb_eSystemCallError) return Qtrue;

num = rb_attr_get(exc, en);

if (NIL_P(num)) {

num = rb_funcall(exc, en, 0, 0);

}

e = rb_const_get(self, rb_intern("Errno"));

if (FIXNUM_P(num) ? num == e : rb_equal(num, e))

return Qtrue;

return Qfalse;

}

/*

* Descendents of class <code>Exception</code> are used to communicate

* between <code>raise</code> methods and <code>rescue</code>

* statements in <code>begin/end</code> blocks. <code>Exception</code>

* objects carry information about the exception---its type (the

* exception's class name), an optional descriptive string, and

* optional traceback information. Programs may subclass

* <code>Exception</code> to add additional information.

*/

void

Init_Exception()

{

rb_eException = rb_define_class("Exception", rb_cObject);

rb_define_singleton_method(rb_eException, "exception", rb_class_new_instance, -1);

rb_define_method(rb_eException, "exception", exc_exception, -1);

rb_define_method(rb_eException, "initialize", exc_initialize, -1);

rb_define_method(rb_eException, "to_s", exc_to_s, 0);

rb_define_method(rb_eException, "to_str", exc_to_str, 0);

rb_define_method(rb_eException, "message", exc_to_str, 0);

rb_define_method(rb_eException, "inspect", exc_inspect, 0);

rb_define_method(rb_eException, "backtrace", exc_backtrace, 0);

rb_define_method(rb_eException, "set_backtrace", exc_set_backtrace, 1);

rb_eSystemExit = rb_define_class("SystemExit", rb_eException);

rb_define_method(rb_eSystemExit, "initialize", exit_initialize, -1);

rb_define_method(rb_eSystemExit, "status", exit_status, 0);

rb_define_method(rb_eSystemExit, "success?", exit_success_p, 0);

rb_eFatal = rb_define_class("fatal", rb_eException);

rb_eSignal = rb_define_class("SignalException", rb_eException);

rb_eInterrupt = rb_define_class("Interrupt", rb_eSignal);

rb_eStandardError = rb_define_class("StandardError", rb_eException);

rb_eTypeError = rb_define_class("TypeError", rb_eStandardError);