exceptionhandler.pmc

/*
Copyright (C) 2001-2011, Parrot Foundation.

=head1 NAME

src/pmc/exceptionhandler.pmc - Exception Handler PMC

=head1 DESCRIPTION

When an exception handler is called, the exception object is passed as
C<REG_PMC(interp, 5)>, the original contents of this register is in the
exception object's C<_P5> attribute.

=head2 Methods

=over 4

=cut

*/

#include "parrot/oplib/ops.h"
#include "pmc/pmc_exception.h"

/* HEADERIZER HFILE: none */
/* HEADERIZER BEGIN: static */
/* HEADERIZER END: static */

pmclass ExceptionHandler extends Continuation provides invokable auto_attrs {

    ATTR PMC    *handled_types;
    ATTR PMC    *handled_types_except;
    ATTR INTVAL min_severity;
    ATTR INTVAL max_severity;

/*

=item C<void init()>

Initializes the exception handler.

=cut

*/

    VTABLE void init() {
        SUPER();

        /* an exception handler has no separate context; it's only a snapshot
         * of an "earlier" context, which is contained in the interpreter's
         * context - the stacks can only be deeper in the interpreter - so no
         * mark of context is needed */
        PObj_custom_mark_SET(SELF);
    }

/*

=item C<void init_int(INTVAL)>

Initializes the exception handler with one handled type.

=cut

*/

    VTABLE void init_int(INTVAL handledtype) {
        Parrot_ExceptionHandler_attributes * const attrs = PARROT_EXCEPTIONHANDLER(SELF);
        SELF.init();

        attrs->handled_types = Parrot_pmc_new_init_int(INTERP, enum_class_FixedIntegerArray, 1);
        VTABLE_set_integer_keyed_int(INTERP, attrs->handled_types, 0, handledtype);
    }


/*

=item C<void init_pmc(PMC)>

Initializes the exception handler with one handled type. If the argument
is a key, intitialize it with the key contents.

=cut

*/

    VTABLE void init_pmc(PMC *handledtype) {
        Parrot_ExceptionHandler_attributes * const attrs = PARROT_EXCEPTIONHANDLER(SELF);
        SELF.init();
        if (handledtype->vtable->base_type == enum_class_Key) {
            PMC *key;
            /* check if the key only consists of integers */
            for (key = handledtype; key; key = Parrot_key_next(INTERP, key))
                if ((PObj_get_FLAGS(key) & KEY_type_FLAGS) != KEY_integer_FLAG)
                    break;
            if (!key) {
                /* yes, directly use the key */
                attrs->handled_types = handledtype;
                return;
            }
            /* no, create a RPA from the key */
            attrs->handled_types = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
            for (key = handledtype; key; key = Parrot_key_next(INTERP, key))
                VTABLE_push_integer(interp, attrs->handled_types, Parrot_key_integer(INTERP, key));
        }
        else {
            INTVAL type = VTABLE_get_integer(INTERP, handledtype);
            attrs->handled_types = Parrot_pmc_new_init_int(INTERP, enum_class_FixedIntegerArray, 1);
            VTABLE_set_integer_keyed_int(INTERP, attrs->handled_types, 0, type);
        }
    }

/*

=item C<void mark()>

Mark any active exception handler data as live.

=cut

*/

    VTABLE void mark() {
        Parrot_ExceptionHandler_attributes * const attrs =
            PARROT_EXCEPTIONHANDLER(SELF);
        Parrot_gc_mark_PMC_alive(INTERP, attrs->handled_types);
        Parrot_gc_mark_PMC_alive(INTERP, attrs->handled_types_except);
        SUPER();
    }

/*

=item C<PMC * get_attr_str(STRING *attr)>

Get the value of an attribute by name

=cut

*/

    VTABLE PMC * get_attr_str(STRING *attr) {
        PMC * val = PMCNULL;
        INTVAL ival;
        /*if (STRING_equal(INTERP, attr, CONST_STRING(INTERP, "seg")))
            GET_ATTR_seg(INTERP, SELF, val);*/
        if (STRING_equal(INTERP, attr, CONST_STRING(INTERP, "to_ctx")))
            GET_ATTR_to_ctx(INTERP, SELF, val);
        else if (STRING_equal(INTERP, attr, CONST_STRING(INTERP, "to_call_object")))
            GET_ATTR_to_call_object(INTERP, SELF, val);
        else if (STRING_equal(INTERP, attr, CONST_STRING(INTERP, "from_ctx")))
            GET_ATTR_from_ctx(INTERP, SELF, val);
        else if (STRING_equal(INTERP, attr, CONST_STRING(INTERP, "runloop_id"))) {
            GET_ATTR_runloop_id(INTERP, SELF, ival);
            val = Parrot_pmc_box_integer(INTERP, ival);
        }
        else if (STRING_equal(INTERP, attr, CONST_STRING(INTERP, "invoked"))) {
            GET_ATTR_invoked(INTERP, SELF, ival);
            val = Parrot_pmc_box_integer(INTERP, ival);
        }
        else
            val = SUPER(attr);
        return val;
    }

    VTABLE PMC *clone() {
        PMC * const result = SUPER();
        /* This looks wrong, why wouldn't we want to mark the clone? */
        PObj_custom_mark_CLEAR(result);
        return result;
    }

/*

=item C<void set_integer_native(INTVAL)>

Mark whether the handler has been invoked.

=cut

*/

    VTABLE void set_integer_native(INTVAL value) {
        PARROT_CONTINUATION(SELF)->invoked = value;
    }

/*

=item C<INTVAL get_integer()>

Check whether the handler has been invoked.

=cut

*/

    VTABLE INTVAL get_integer() {
        return PARROT_CONTINUATION(SELF)->invoked;
    }

/*

=item C<opcode_t *invoke(void *next)>

Set up the environment for the exception handler to be invoked.

=cut

*/

    VTABLE opcode_t *invoke(void *next) {
        opcode_t    * const pc = PARROT_CONTINUATION(SELF)->address;

        Parrot_sub_continuation_check(INTERP, SELF);
        Parrot_sub_continuation_rewind_environment(INTERP, SELF);

        /* switch code segment if needed */
        if (INTERP->code != PARROT_CONTINUATION(SELF)->seg)
            Parrot_switch_to_cs(INTERP, PARROT_CONTINUATION(SELF)->seg, 1);

        return pc;
    }


/*

=back

=head2 Methods

=over 4

=cut

*/

/*

=item C<METHOD can_handle(PMC *exception)>

Report whether the exception handler can handle a particular type of exception.

=cut

*/

    METHOD can_handle(PMC *exception) {
        STRING * const ex_str = CONST_STRING(INTERP, "Exception");

        /* We handle Exception and anything that claims to implement that role
           here. Include the base_type check as a sort of optimization */
        if (exception->vtable->base_type == enum_class_Exception
        ||  VTABLE_isa(INTERP, exception, ex_str)) {
            INTVAL severity;
            PMC *handled_types;
            PMC *handled_types_except;
            INTVAL min_severity, max_severity;
            GET_ATTR_max_severity(INTERP, SELF, max_severity);
            GET_ATTR_min_severity(INTERP, SELF, min_severity);

            if (exception->vtable->base_type == enum_class_Exception)
                GETATTR_Exception_severity(INTERP, exception, severity);
            else {
                STRING * const severity_str = CONST_STRING(INTERP, "severity");
                severity = VTABLE_get_integer_keyed_str(INTERP, exception, severity_str);
            }

            if (severity < min_severity) {
                RETURN(INTVAL 0);
            }
            if (max_severity > 0 &&  severity > max_severity) {
                RETURN(INTVAL 0);
            }

            GET_ATTR_handled_types(INTERP, SELF, handled_types);
            if (! PMC_IS_NULL(handled_types)) {
                INTVAL type;

                if (exception->vtable->base_type == enum_class_Exception)
                    GETATTR_Exception_type(INTERP, exception, type);
                else {
                    STRING * const type_str = CONST_STRING(INTERP, "type");
                    type = VTABLE_get_integer_keyed_str(INTERP, exception, type_str);
                }
                if (handled_types->vtable->base_type == enum_class_Key) {
                    PMC *key = handled_types;
                    for (; key; key = Parrot_key_next(INTERP, key)) {
                        const INTVAL handled_type = Parrot_key_integer(INTERP, key);
                        if (handled_type == type ||
                                handled_type == (type | EXCEPTION_TYPE_ALL_MASK))
                            RETURN(INTVAL 1);
                    }
                }
                else {
                    const INTVAL elems = VTABLE_elements(INTERP, handled_types);
                    INTVAL i;

                    for (i = 0; i < elems; ++i) {
                        const INTVAL handled_type =
                            VTABLE_get_integer_keyed_int(INTERP, handled_types, i);
                        if (handled_type == type ||
                                handled_type == (type | EXCEPTION_TYPE_ALL_MASK))
                            RETURN(INTVAL 1);
                    }
                }

                RETURN(INTVAL 0);
            }
            GET_ATTR_handled_types_except(INTERP, SELF, handled_types_except);
            if (! PMC_IS_NULL(handled_types_except)) {
                const INTVAL elems = VTABLE_elements(INTERP, handled_types_except);
                INTVAL i, type;

                if (exception->vtable->base_type == enum_class_Exception)
                    GETATTR_Exception_type(INTERP, exception, type);
                else {
                    STRING * const type_str = CONST_STRING(INTERP, "type");
                    type = VTABLE_get_integer_keyed_str(INTERP, exception, type_str);
                }

                for (i = 0; i < elems; ++i) {
                    const INTVAL handled_type = VTABLE_get_integer_keyed_int(INTERP,
                            handled_types_except, i);
                    if (handled_type == type || handled_type == (type | EXCEPTION_TYPE_ALL_MASK))
                        RETURN(INTVAL 0);
                }
            }

            RETURN(INTVAL 1);
        }

        RETURN(INTVAL 0);
    }

/*

=item C<METHOD min_severity(INTVAL severity :optional, INTVAL have_severity :opt_flag)>

Set or get the minimum severity of the exception handler.

=cut

*/

    METHOD min_severity(INTVAL severity :optional, INTVAL have_severity :opt_flag) {
        Parrot_ExceptionHandler_attributes * const attrs =
                    PARROT_EXCEPTIONHANDLER(SELF);

        if (have_severity)
            attrs->min_severity = severity;
        else
            severity = attrs->min_severity;

        RETURN(INTVAL severity);
    }

/*

=item C<METHOD max_severity(INTVAL severity :optional, INTVAL have_severity :opt_flag)>

Set or get the maximum severity of the exception handler.

=cut

*/

    METHOD max_severity(INTVAL severity :optional, INTVAL have_severity :opt_flag) {
        Parrot_ExceptionHandler_attributes * const attrs =
                    PARROT_EXCEPTIONHANDLER(SELF);

        if (have_severity)
            attrs->max_severity = severity;
        else
            severity = attrs->max_severity;

        RETURN(INTVAL severity);
    }

/*

=item C<METHOD handle_types(PMC *types :slurpy)>

Set the exception types that the ExceptionHandler will handle.

=cut

*/

    METHOD handle_types(PMC *types :slurpy) {
        Parrot_ExceptionHandler_attributes * const attrs =
                    PARROT_EXCEPTIONHANDLER(SELF);
        attrs->handled_types =
            VTABLE_elements(INTERP, types) > 0
                ? types
                : PMCNULL;
    }

/*

=item C<METHOD handle_types_except(PMC *types :slurpy)>

Set the exception types that the ExceptionHandler will not handle.

=cut

*/

    METHOD handle_types_except(PMC *types :slurpy) {
        Parrot_ExceptionHandler_attributes * const attrs =
                    PARROT_EXCEPTIONHANDLER(SELF);
        attrs->handled_types_except =
            VTABLE_elements(INTERP, types) > 0
                ? types
                : PMCNULL;
    }

}

/*

=back

=cut

*/

/*
 * Local variables:
 *   c-file-style: "parrot"
 * End:
 * vim: expandtab shiftwidth=4 cinoptions='\:2=2' :
 */