src/pmc/exception_handler.pmc

   1 /*
   2 Copyright (C) 2001-2007, The Perl Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/pmc/exception_handler.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/parrot.h"
  24 #include "parrot/oplib/ops.h"
  25
  26 static opcode_t *
  27 pass_exception_args(PARROT_INTERP, const char *sig,
  28         opcode_t *dest, parrot_context_t * old_ctx, ...)
  29 {
  30     va_list   ap;
  31     opcode_t *next;
  32
  33     va_start(ap, old_ctx);
  34     next = parrot_pass_args_fromc(interp, sig, dest, old_ctx, ap);
  35     va_end(ap);
  36
  37     return next;
  38 }
  39
  40 pmclass Exception_Handler extends Continuation need_ext {
  41
  42 /*
  43
  44 =item C<void init()>
  45
  46 Initializes the exception handler.
  47
  48 =cut
  49
  50 */
  51
  52     VTABLE void init() {
  53         PMC_struct_val(SELF) = new_continuation(INTERP, NULL);
  54         PMC_pmc_val(SELF)    = PMCNULL;
  55
  56         /* an exception handler has no separate context; it's only a snapshot
  57          * of an "earlier" context, which is contained in the interpreter's
  58          * context - the stacks can only be deeper in the interpreter - so no
  59          * mark of context is needed */
  60         PObj_active_destroy_SET(SELF);
  61     }
  62
  63     /*
  64      * can't reuse Continuation's destroy yet -
  65      * RT#46703 fix ref_count handling for exception_handlers first
  66      *
  67      * An Exception_Handler is kind of a limited Continuation
  68      * (can only call 'up the stack').  Therefore we probably don't
  69      * have to convert all RetContinuations to real Continuations
  70      */
  71
  72     VTABLE void destroy() {
  73         Parrot_cont * const cc = PMC_cont(SELF);
  74
  75         if (cc) {
  76             mem_sys_free(cc);
  77             PMC_struct_val(SELF) = NULL;
  78         }
  79     }
  80
  81     VTABLE PMC *clone() {
  82         PMC * const result = SUPER();
  83         PObj_custom_mark_CLEAR(result);
  84         return result;
  85     }
  86
  87     VTABLE opcode_t *invoke(void *ex) {
  88         Parrot_cont        *cc        = PMC_cont(SELF);
  89         PMC                *exception = (PMC *)ex;
  90         opcode_t           *next      = NULL;
  91         parrot_context_t   *ex_ctx;
  92         opcode_t           *results;
  93
  94         /* COMPAT:  PMC *p5 = REG_PMC(interp, 5);*/
  95
  96         PARROT_ASSERT(cc->to_ctx == cc->from_ctx);
  97         results = cc->current_results;
  98
  99         /* clear all results, so that continuation.invoke
 100          * doesn't pass any args #' */
 101         cc->to_ctx->current_results = cc->current_results = NULL;
 102         ex_ctx                      = CONTEXT(interp);
 103         next                        = SUPER(next);
 104
 105         if (results) {
 106             STRING *message = VTABLE_get_string_keyed_int(INTERP,
 107                     exception, 0);
 108             PARROT_ASSERT(next == results);
 109             next            = pass_exception_args(interp, "PS", next,
 110                                                   ex_ctx, exception, message);
 111         }
 112
 113         return next;
 114     }
 115 }
 116
 117 /*
 118
 119 =back
 120
 121 =head1 HISTORY
 122
 123 Initial revision by leo 2003.07.10.
 124
 125 =cut
 126
 127 */
 128
 129 /*
 130  * Local variables:
 131  *   c-file-style: "parrot"
 132  * End:
 133  * vim: expandtab shiftwidth=4:
 134  */