kernel/core/exception.rb

   1 # depends on: class.rb
   2
   3 class Exception
   4
   5   ivar_as_index :__ivars => 0, :message => 1, :context => 2
   6   def message; @message ; end
   7
   8   def initialize(message = nil)
   9     @message = message
  10     @context = nil
  11     @backtrace = nil
  12   end
  13
  14   def backtrace
  15     return @backtrace if @backtrace
  16     return nil unless @context
  17     awesome_backtrace.to_mri
  18   end
  19
  20   def awesome_backtrace
  21     return nil unless @context
  22     @backtrace = Backtrace.backtrace(@context)
  23   end
  24
  25   def set_backtrace(bt)
  26     @backtrace = bt
  27   end
  28
  29   def to_s
  30     @message || self.class.to_s
  31   end
  32
  33   def inspect
  34     "#<#{self.class.name}: #{self.to_s}>"
  35   end
  36
  37   alias_method :message, :to_s
  38   alias_method :to_str, :to_s
  39
  40   def self.exception(message=nil)
  41     self.new(message)
  42   end
  43
  44   def exception(message=nil)
  45     if message
  46       self.class.new(message)
  47     else
  48       self
  49     end
  50   end
  51
  52   def context
  53     @context
  54   end
  55
  56   def context=(other)
  57     @context = other
  58   end
  59
  60   def location
  61     ctx = self.context
  62     [ctx.file.to_s, ctx.line]
  63   end
  64 end
  65
  66 ##
  67 # Primitive fails from opcode "send_primitive"
  68
  69 class PrimitiveFailure < Exception
  70 end
  71
  72 class ScriptError < Exception
  73 end
  74
  75 class StandardError < Exception
  76 end
  77
  78 class SignalException < Exception
  79 end
  80
  81 class NoMemoryError < Exception
  82 end
  83
  84 class ZeroDivisionError < StandardError
  85 end
  86
  87 class ArgumentError < StandardError
  88 end
  89
  90 class IndexError < StandardError
  91 end
  92
  93 class RangeError < StandardError
  94 end
  95
  96 class FloatDomainError < RangeError
  97 end
  98
  99 class LocalJumpError < StandardError
 100 end
 101
 102 class NameError < StandardError
 103   attr_reader :name
 104   def initialize(*args)
 105     super(args.shift)
 106     @name = args.shift
 107   end
 108 end
 109
 110 class NoMethodError < NameError
 111   attr_reader :name
 112   attr_reader :args
 113   def initialize(*arguments)
 114     super(arguments.shift)
 115     @name = arguments.shift
 116     @args = arguments.shift
 117   end
 118 end
 119
 120 class RuntimeError < StandardError
 121 end
 122
 123 class SecurityError < StandardError
 124 end
 125
 126 class SystemStackError < StandardError
 127 end
 128
 129 class ThreadError < StandardError
 130 end
 131
 132 class TypeError < StandardError
 133 end
 134
 135 class FloatDomainError < RangeError
 136 end
 137
 138 class RegexpError < StandardError
 139 end
 140
 141 class LoadError < ScriptError
 142 end
 143
 144 class NotImplementedError < ScriptError
 145 end
 146
 147 class Interrupt < SignalException
 148 end
 149
 150 class IOError < StandardError
 151 end
 152
 153 class EOFError < IOError
 154 end
 155
 156 class LocalJumpError < StandardError
 157 end
 158
 159 class NotImplementedError < ScriptError
 160 end
 161
 162 class SyntaxError < ScriptError
 163   attr_accessor :column
 164   attr_accessor :line
 165   attr_accessor :file
 166   attr_accessor :code
 167
 168   def import_position(c,l, code)
 169     @column = c
 170     @line = l
 171     @code = code
 172   end
 173
 174   def message
 175     msg = super
 176     msg = "#{file}:#{@line}: #{msg}" if file && @line
 177     msg
 178   end
 179 end
 180
 181 class SystemCallError < StandardError
 182   def errno; @errno ; end
 183
 184   def initialize(message, errno = nil)
 185     if message.is_a?(Integer) && errno.nil?
 186       errno   = message
 187       message = "Unknown error"
 188     end
 189     super(message)
 190     @errno = errno
 191   end
 192 end
 193
 194 ##
 195 # Raised when you try to return from a block when not allowed.  Never seen by
 196 # ruby code.
 197
 198 class IllegalLongReturn < LocalJumpError
 199   attr_reader :return_value
 200 end
 201
 202 ##
 203 # Abstract class for implementing flow control in Rubinius.  Never seen by
 204 # ruby code.
 205
 206 class FlowControlException < Exception
 207 end
 208
 209 ##
 210 # Flow control exception used to implement return inside an ensure.  Never
 211 # seen by ruby code.
 212
 213 class ReturnException < FlowControlException
 214   attr_reader :return_value
 215
 216   def initialize(val)
 217     super(nil) # HACK
 218     @return_value = val
 219   end
 220 end
 221
 222 ##
 223 # Raised when returning from a block to handle proper flow control.  Never
 224 # seen by ruby code.
 225
 226 class LongReturnException < FlowControlException
 227   attr_reader :value
 228   attr_reader :is_return
 229
 230   def return_value=(val)
 231     @value = val
 232     @is_return = true
 233   end
 234
 235   def break_value=(val)
 236     @value = val
 237     @is_return = false
 238   end
 239
 240 end