src/pmc/exceptionhandler.pmc

   1 /*
   2 Copyright (C) 2001-2008, Parrot Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/pmc/exceptionhandler.pmc - Exception Handler PMC
   8
   9 =head1 DESCRIPTION
  10
  11 When an exception handler is called, the exception object is passed as
  12 C<REG_PMC(interp, 5)>, the original contents of this register is in the
  13 exception object's C<_P5> attribute.
  14
  15 =head2 Methods
  16
  17 =over 4
  18
  19 =cut
  20
  21 */
  22
  23 #include "parrot/oplib/ops.h"
  24
  25 /* HEADERIZER HFILE: none */
  26 /* HEADERIZER BEGIN: static */
  27 /* HEADERIZER END: static */
  28
  29 pmclass ExceptionHandler extends Continuation provides invokable auto_attrs {
  30
  31     ATTR PMC    *handled_types;
  32     ATTR PMC    *handled_types_except;
  33     ATTR INTVAL min_severity;
  34     ATTR INTVAL max_severity;
  35
  36 /*
  37
  38 =item C<void init()>
  39
  40 Initializes the exception handler.
  41
  42 =cut
  43
  44 */
  45
  46     VTABLE void init() {
  47         Parrot_ExceptionHandler_attributes * const attrs = PARROT_EXCEPTIONHANDLER(SELF);
  48         SUPER();
  49         attrs->invoked              = 0;
  50         attrs->min_severity         = 0;
  51         attrs->max_severity         = 0;
  52         attrs->handled_types        = PMCNULL;
  53         attrs->handled_types_except = PMCNULL;
  54
  55         /* an exception handler has no separate context; it's only a snapshot
  56          * of an "earlier" context, which is contained in the interpreter's
  57          * context - the stacks can only be deeper in the interpreter - so no
  58          * mark of context is needed */
  59         PObj_custom_mark_SET(SELF);
  60     }
  61
  62 /*
  63
  64 =item C<void mark()>
  65
  66 Mark any active exception handler data as live.
  67
  68 =cut
  69
  70 */
  71
  72     VTABLE void mark() {
  73         Parrot_ExceptionHandler_attributes * const attrs =
  74             PARROT_EXCEPTIONHANDLER(SELF);
  75         Parrot_gc_mark_PMC_alive(INTERP, attrs->handled_types);
  76         Parrot_gc_mark_PMC_alive(INTERP, attrs->handled_types_except);
  77         SUPER();
  78     }
  79
  80     VTABLE PMC *clone() {
  81         PMC * const result = SUPER();
  82         /* This looks wrong, why wouldn't we want to mark the clone? */
  83         PObj_custom_mark_CLEAR(result);
  84         return result;
  85     }
  86
  87 /*
  88
  89 =item C<void set_integer_native(INTVAL)>
  90
  91 Mark whether the handler has been invoked.
  92
  93 =cut
  94
  95 */
  96
  97     VTABLE void set_integer_native(INTVAL value) {
  98         PARROT_CONTINUATION(SELF)->invoked = value;
  99     }
 100
 101 /*
 102
 103 =item C<INTVAL get_integer()>
 104
 105 Check whether the handler has been invoked.
 106
 107 =cut
 108
 109 */
 110
 111     VTABLE INTVAL get_integer() {
 112         return PARROT_CONTINUATION(SELF)->invoked;
 113     }
 114
 115 /*
 116
 117 =item C<opcode_t *invoke(void *next)>
 118
 119 Set up the environment for the exception handler to be invoked.
 120
 121 =cut
 122
 123 */
 124
 125     VTABLE opcode_t *invoke(void *next) {
 126         opcode_t    * const pc = PARROT_CONTINUATION(SELF)->address;
 127
 128         Parrot_continuation_check(INTERP, SELF);
 129         Parrot_continuation_rewind_environment(INTERP, SELF);
 130
 131         /* switch code segment if needed */
 132         if (INTERP->code != PARROT_CONTINUATION(SELF)->seg)
 133             Parrot_switch_to_cs(INTERP, PARROT_CONTINUATION(SELF)->seg, 1);
 134
 135         return pc;
 136     }
 137
 138
 139 /*
 140
 141 =back
 142
 143 =head2 Methods
 144
 145 =over 4
 146
 147 =cut
 148
 149 */
 150
 151 /*
 152
 153 =item C<METHOD can_handle(PMC *exception)>
 154
 155 Report whether the exception handler can handle a particular type of exception.
 156
 157 =cut
 158
 159 */
 160
 161     METHOD can_handle(PMC *exception) {
 162         STRING * const sev    = CONST_STRING(INTERP, "severity");
 163         STRING * const ex_str = CONST_STRING(INTERP, "Exception");
 164
 165         INTVAL severity = VTABLE_get_integer_keyed_str(INTERP, exception, sev);
 166
 167         if (exception->vtable->base_type == enum_class_Exception
 168         ||  VTABLE_isa(INTERP, exception, ex_str)) {
 169             PMC *handled_types;
 170             PMC *handled_types_except;
 171             INTVAL min_severity, max_severity;
 172             GET_ATTR_handled_types(INTERP, SELF, handled_types);
 173             GET_ATTR_handled_types_except(INTERP, SELF, handled_types_except);
 174             GET_ATTR_max_severity(INTERP, SELF, max_severity);
 175             GET_ATTR_min_severity(INTERP, SELF, min_severity);
 176
 177             if (severity < min_severity) {
 178                 RETURN(INTVAL 0);
 179             }
 180             if (max_severity > 0 &&  severity > max_severity) {
 181                 RETURN(INTVAL 0);
 182             }
 183             if (! PMC_IS_NULL(handled_types)) {
 184                 const INTVAL elems = VTABLE_elements(INTERP, handled_types);
 185                 const INTVAL type  = VTABLE_get_integer_keyed_str(INTERP, exception, CONST_STRING(INTERP, "type"));
 186                 INTVAL i;
 187
 188                 for (i = 0; i < elems; ++i) {
 189                     INTVAL handled_type = VTABLE_get_integer_keyed_int(INTERP,
 190                             handled_types, i);
 191                     if (handled_type == type)
 192                         RETURN(INTVAL 1);
 193                 }
 194
 195                 RETURN(INTVAL 0);
 196             }
 197             if (handled_types_except != PMCNULL) {
 198                 const INTVAL elems = VTABLE_elements(INTERP, handled_types_except);
 199                 const INTVAL type  = VTABLE_get_integer_keyed_str(INTERP, exception, CONST_STRING(INTERP, "type"));
 200                 INTVAL i;
 201
 202                 for (i = 0; i < elems; ++i) {
 203                     const INTVAL handled_type = VTABLE_get_integer_keyed_int(INTERP,
 204                             handled_types_except, i);
 205                     if (handled_type == type)
 206                         RETURN(INTVAL 0);
 207                 }
 208
 209                 RETURN(INTVAL 1);
 210             }
 211             else if (max_severity > 0 || min_severity > 0) {
 212                 RETURN(INTVAL 1);
 213             }
 214
 215             RETURN(INTVAL 1);
 216         }
 217
 218         RETURN(INTVAL 0);
 219     }
 220
 221 /*
 222
 223 =item C<METHOD min_severity(INTVAL severity :optional, INTVAL have_severity :opt_flag)>
 224
 225 Set or get the minimum severity of the exception handler.
 226
 227 =cut
 228
 229 */
 230
 231     METHOD min_severity(INTVAL severity :optional, INTVAL have_severity :opt_flag) {
 232         Parrot_ExceptionHandler_attributes * const attrs =
 233                     PARROT_EXCEPTIONHANDLER(SELF);
 234
 235         if (have_severity)
 236             attrs->min_severity = severity;
 237         else
 238             severity = attrs->min_severity;
 239
 240         RETURN(INTVAL severity);
 241     }
 242
 243 /*
 244
 245 =item C<METHOD max_severity(INTVAL severity :optional, INTVAL have_severity :opt_flag)>
 246
 247 Set or get the maximum severity of the exception handler.
 248
 249 =cut
 250
 251 */
 252
 253     METHOD max_severity(INTVAL severity :optional, INTVAL have_severity :opt_flag) {
 254         Parrot_ExceptionHandler_attributes * const attrs =
 255                     PARROT_EXCEPTIONHANDLER(SELF);
 256
 257         if (have_severity)
 258             attrs->max_severity = severity;
 259         else
 260             severity = attrs->max_severity;
 261
 262         RETURN(INTVAL severity);
 263     }
 264
 265 /*
 266
 267 =item C<METHOD handle_types(PMC *types :slurpy)>
 268
 269 Set the exception types that the ExceptionHandler will handle.
 270
 271 =cut
 272
 273 */
 274
 275     METHOD handle_types(PMC *types :slurpy) {
 276         Parrot_ExceptionHandler_attributes * const attrs =
 277                     PARROT_EXCEPTIONHANDLER(SELF);
 278         attrs->handled_types =
 279             VTABLE_elements(INTERP, types) > 0
 280                 ? types
 281                 : PMCNULL;
 282     }
 283
 284 /*
 285
 286 =item C<METHOD handle_types_except(PMC *types :slurpy)>
 287
 288 Set the exception types that the ExceptionHandler will not handle.
 289
 290 =cut
 291
 292 */
 293
 294     METHOD handle_types_except(PMC *types :slurpy) {
 295         Parrot_ExceptionHandler_attributes * const attrs =
 296                     PARROT_EXCEPTIONHANDLER(SELF);
 297         attrs->handled_types_except =
 298             VTABLE_elements(INTERP, types) > 0
 299                 ? types
 300                 : PMCNULL;
 301     }
 302
 303 }
 304
 305 /*
 306
 307 =back
 308
 309 =cut
 310
 311 */
 312
 313 /*
 314  * Local variables:
 315  *   c-file-style: "parrot"
 316  * End:
 317  * vim: expandtab shiftwidth=4:
 318  */