Changeset 69c5c00 for libcfa/src


Ignore:
Timestamp:
Oct 7, 2020, 6:08:35 PM (5 years ago)
Author:
Andrew Beach <ajbeach@…>
Branches:
ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum
Children:
6fbe9a5
Parents:
41b8ea4
Message:

Rework exceptions mark_exception -> get_exception_vtable and the needed follow up.

Location:
libcfa/src
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/concurrency/coroutine.cfa

    r41b8ea4 r69c5c00  
    4747
    4848//-----------------------------------------------------------------------------
    49 FORALL_DATA_INSTANCE(CoroutineCancelled,
    50                 (dtype coroutine_t | sized(coroutine_t)), (coroutine_t))
     49FORALL_DATA_INSTANCE(CoroutineCancelled, (dtype coroutine_t), (coroutine_t))
    5150
    5251struct __cfaehm_node {
    … …  
    5958void mark_exception(CoroutineCancelled(T) *) {}
    6059
    61 forall(dtype T | sized(T))
     60forall(dtype T)
    6261void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src) {
    6362        dst->the_coroutine = src->the_coroutine;
    … …  
    7776        exception_t * except = (exception_t *)(1 + (__cfaehm_node *)desc->cancellation);
    7877
     78        // TODO: Remove explitate vtable set once trac#186 is fixed.
    7979        CoroutineCancelled(T) except;
     80        except.virtual_table = &get_exception_vtable(&except);
    8081        except.the_coroutine = &cor;
    8182        except.the_exception = except;

  • libcfa/src/concurrency/coroutine.hfa

    r41b8ea4 r69c5c00  
    2222//-----------------------------------------------------------------------------
    2323// Exception thrown from resume when a coroutine stack is cancelled.
    24 // Should not have to be be sized (see trac #196).
    25 FORALL_DATA_EXCEPTION(CoroutineCancelled,
    26                 (dtype coroutine_t | sized(coroutine_t)), (coroutine_t)) (
     24FORALL_DATA_EXCEPTION(CoroutineCancelled, (dtype coroutine_t), (coroutine_t)) (
    2725        coroutine_t * the_coroutine;
    2826        exception_t * the_exception;
    … …  
    3028
    3129forall(dtype T)
    32 void mark_exception(CoroutineCancelled(T) *);
    33 
    34 forall(dtype T | sized(T))
    3530void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src);
    3631
    … …  
    4237// Anything that implements this trait can be resumed.
    4338// Anything that is resumed is a coroutine.
    44 trait is_coroutine(dtype T | sized(T)
    45                 | is_resumption_exception(CoroutineCancelled(T))
    46                 | VTABLE_ASSERTION(CoroutineCancelled, (T))) {
     39trait is_coroutine(dtype T
     40                | is_resumption_exception(CoroutineCancelled(T),
     41                        CoroutineCancelled_vtable(T))) {
    4742        void main(T & this);
    4843        $coroutine * get_coroutine(T & this);

  • libcfa/src/exception.h

    r41b8ea4 r69c5c00  
    7676// implemented in the .c file either so they all have to be inline.
    7777
    78 trait is_exception(dtype exceptT) {
     78trait is_exception(dtype exceptT, dtype virtualT) {
    7979        /* The first field must be a pointer to a virtual table.
    80          * That virtual table must be a decendent of the base exception virtual tab$
     80         * That virtual table must be a decendent of the base exception virtual table.
    8181         */
    82         void mark_exception(exceptT *);
    83         // This is never used and should be a no-op.
     82        virtualT const & get_exception_vtable(exceptT *);
     83        // Always returns the virtual table for this type (associated types hack).
    8484};
    8585
    86 trait is_termination_exception(dtype exceptT | is_exception(exceptT)) {
     86trait is_termination_exception(dtype exceptT, dtype virtualT | is_exception(exceptT, virtualT)) {
    8787        void defaultTerminationHandler(exceptT &);
    8888};
    8989
    90 trait is_resumption_exception(dtype exceptT | is_exception(exceptT)) {
     90trait is_resumption_exception(dtype exceptT, dtype virtualT | is_exception(exceptT, virtualT)) {
    9191        void defaultResumptionHandler(exceptT &);
    9292};
    9393
    94 forall(dtype exceptT | is_termination_exception(exceptT))
     94forall(dtype exceptT, dtype virtualT | is_termination_exception(exceptT, virtualT))
    9595static inline void $throw(exceptT & except) {
    9696        __cfaehm_throw_terminate(
    … …  
    100100}
    101101
    102 forall(dtype exceptT | is_resumption_exception(exceptT))
     102forall(dtype exceptT, dtype virtualT | is_resumption_exception(exceptT, virtualT))
    103103static inline void $throwResume(exceptT & except) {
    104104        __cfaehm_throw_resume(
    … …  
    108108}
    109109
    110 forall(dtype exceptT | is_exception(exceptT))
     110forall(dtype exceptT, dtype virtualT | is_exception(exceptT, virtualT))
    111111static inline void cancel_stack(exceptT & except) __attribute__((noreturn)) {
    112112        __cfaehm_cancel_stack( (exception_t *)&except );
    113113}
    114114
    115 forall(dtype exceptT | is_exception(exceptT))
     115forall(dtype exceptT, dtype virtualT | is_exception(exceptT, virtualT))
    116116static inline void defaultTerminationHandler(exceptT & except) {
    117117        return cancel_stack( except );
    118118}
    119119
    120 forall(dtype exceptT | is_exception(exceptT))
     120forall(dtype exceptT, dtype virtualT | is_exception(exceptT, virtualT))
    121121static inline void defaultResumptionHandler(exceptT & except) {
    122122        throw except;

  • libcfa/src/exception.hfa

    r41b8ea4 r69c5c00  
    9595// visible anywhere you use the instantiation of the exception is used.
    9696#define POLY_VTABLE_DECLARATION(exception_name, ...) \
    97         void mark_exception(exception_name(__VA_ARGS__) *); \
     97        VTABLE_TYPE(exception_name)(__VA_ARGS__) const & get_exception_vtable(exception_name(__VA_ARGS__) *); \
    9898        extern VTABLE_TYPE(exception_name)(__VA_ARGS__) VTABLE_NAME(exception_name)
    9999
    … …  
    160160
    161161#define _FORALL_CTOR0_DECLARATION(exception_name, assertions, parameters) \
    162         forall(_UNPACK assertions | VTABLE_ASSERTION(exception_name, parameters) ) \
     162        forall(_UNPACK assertions | \
     163                is_exception(exception_name parameters, VTABLE_TYPE(exception_name) parameters)) \
    163164        void ?{}(exception_name parameters & this)
    164165
    165166#define _FORALL_CTOR0_INSTANCE(exception_name, assertions, parameters) \
    166167        _FORALL_CTOR0_DECLARATION(exception_name, assertions, parameters) { \
    167                 VTABLE_INIT(this, exception_name); \
     168                (this).virtual_table = &get_exception_vtable(&this); \
    168169        }
    169170
    … …  
    185186#define _VTABLE_DECLARATION(exception_name, parent_name, ...) \
    186187        struct exception_name; \
    187         void mark_exception(exception_name *); \
    188188        VTABLE_TYPE(exception_name); \
     189        VTABLE_TYPE(exception_name) const & get_exception_vtable(exception_name *); \
    189190        extern VTABLE_TYPE(exception_name) VTABLE_NAME(exception_name); \
    190191        VTABLE_TYPE(exception_name) { \
    … …  
    197198
    198199#define _VTABLE_INSTANCE(exception_name, parent_name, ...) \
    199         void mark_exception(exception_name *) {} \
     200        VTABLE_TYPE(exception_name) const & get_exception_vtable(exception_name *) { \
     201                return VTABLE_NAME(exception_name); \
     202        } \
    200203        void _GLUE2(exception_name,_copy)(exception_name * this, exception_name * other) { \
    201204                *this = *other; \
    … …  
    218221
    219222#define _POLY_VTABLE_INSTANCE(exception_name, parent_name, ...) \
    220         void mark_exception(exception_name(__VA_ARGS__) *) {} \
     223        extern VTABLE_TYPE(exception_name)(__VA_ARGS__) VTABLE_NAME(exception_name); \
     224        VTABLE_TYPE(exception_name)(__VA_ARGS__) const & get_exception_vtable( \
     225                        exception_name(__VA_ARGS__) *) { \
     226                return VTABLE_NAME(exception_name); \
     227        } \
    221228        void _GLUE2(exception_name,_copy)( \
    222229                        exception_name(__VA_ARGS__) * this, exception_name(__VA_ARGS__) * other) { \
Note: See TracChangeset for help on using the changeset viewer.