Changeset e7d6968


Ignore:
Timestamp:
Oct 23, 2020, 9:08:09 PM (2 years ago)
Author:
Fangren Yu <f37yu@…>
Branches:
arm-eh, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum
Children:
c532847
Parents:
37b7d95 (diff), 3aec25f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc into master

Files:
3 added
53 edited
3 moved

Legend:

Unmodified
Added
Removed

  • Jenkins/FullBuild

    r37b7d95 re7d6968  
    1717
    1818                                parallel (
    19                                         clang_x86: { trigger_build( 'gcc-8',   'x86' ) },
    20                                         gcc_5_x86: { trigger_build( 'gcc-7',   'x86' ) },
     19                                        gcc_8_x86: { trigger_build( 'gcc-8',   'x86' ) },
     20                                        gcc_7_x86: { trigger_build( 'gcc-7',   'x86' ) },
    2121                                        gcc_6_x86: { trigger_build( 'gcc-6',   'x86' ) },
    2222                                        gcc_9_x64: { trigger_build( 'gcc-9',   'x64' ) },

  • Jenkinsfile

    r37b7d95 re7d6968  
    127127                        }
    128128
    129                         sh "${SrcDir}/configure CXX=${Settings.Compiler.CXX} CC=${Settings.Compiler.CC} ${Settings.Architecture.flags} AR=gcc-ar RANLIB=gcc-ranlib ${targets} --quiet --prefix=${BuildDir}"
     129                        ast = Settings.NewAST ? "--enable-new-ast" : "--disable-new-ast"
     130
     131                        sh "${SrcDir}/configure CXX=${Settings.Compiler.CXX} CC=${Settings.Compiler.CC} ${Settings.Architecture.flags} AR=gcc-ar RANLIB=gcc-ranlib ${targets} ${ast} --quiet --prefix=${BuildDir}"
    130132
    131133                        // Configure libcfa
    … …  
    359361        public final CC_Desc Compiler
    360362        public final Arch_Desc Architecture
     363        public final Boolean NewAST
    361364        public final Boolean RunAllTests
    362365        public final Boolean RunBenchmark
    … …  
    392395                        break
    393396                        case 'clang':
    394                                 this.Compiler = new CC_Desc('clang', 'clang++-6.0', 'gcc-6', '-flto=thin -flto-jobs=0')
     397                                this.Compiler = new CC_Desc('clang', 'clang++-10', 'gcc-9', '-flto=thin -flto-jobs=0')
    395398                        break
    396399                        default :
    … …  
    410413
    411414                this.IsSandbox          = (branch == "jenkins-sandbox")
     415                this.NewAST             = param.NewAST
    412416                this.RunAllTests        = param.RunAllTests
    413417                this.RunBenchmark       = param.RunBenchmark
    … …  
    470474                                ],                                                                                              \
    471475                                [$class: 'BooleanParameterDefinition',                                                  \
     476                                        description: 'If true, build compiler using new AST',           \
     477                                        name: 'NewAST',                                                                         \
     478                                        defaultValue: false,                                                            \
     479                                ],                                                                                              \
     480                                [$class: 'BooleanParameterDefinition',                                                  \
    472481                                        description: 'If false, only the quick test suite is ran',              \
    473482                                        name: 'RunAllTests',                                                            \
    474483                                        defaultValue: false,                                                            \
    475                                 ],                                                                                              \
     484                                ],
    476485                                [$class: 'BooleanParameterDefinition',                                                  \
    477486                                        description: 'If true, jenkins also runs benchmarks',           \

  • libcfa/prelude/builtins.c

    r37b7d95 re7d6968  
    1010// Created On       : Fri Jul 21 16:21:03 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jul 13 21:10:02 2020
    13 // Update Count     : 109
     12// Last Modified On : Fri Oct  9 18:26:19 2020
     13// Update Count     : 110
    1414//
    1515
    … …  
    9494// universal typed pointer constant
    9595static inline forall( dtype DT ) DT * intptr( uintptr_t addr ) { return (DT *)addr; }
     96static inline forall( ftype FT ) FT * intptr( uintptr_t addr ) { return (FT *)addr; }
    9697
    9798#if defined(__SIZEOF_INT128__)

  • libcfa/src/concurrency/coroutine.cfa

    r37b7d95 re7d6968  
    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;
    … …  
    9192
    9293// minimum feasible stack size in bytes
    93 #define MinStackSize 1000
     94static const size_t MinStackSize = 1000;
    9495extern size_t __page_size;                              // architecture pagesize HACK, should go in proper runtime singleton
    9596

  • libcfa/src/concurrency/coroutine.hfa

    r37b7d95 re7d6968  
    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 | IS_RESUMPTION_EXCEPTION(CoroutineCancelled, (T))) {
    4740        void main(T & this);
    4841        $coroutine * get_coroutine(T & this);

  • libcfa/src/concurrency/io.cfa

    r37b7d95 re7d6968  
    134134                int ret = 0;
    135135                if( need_sys_to_submit || need_sys_to_complete ) {
    136                         ret = syscall( __NR_io_uring_enter, ring.fd, to_submit, 0, flags, 0p, _NSIG / 8);
     136                        ret = syscall( __NR_io_uring_enter, ring.fd, to_submit, 0, flags, (sigset_t *)0p, _NSIG / 8);
    137137                        if( ret < 0 ) {
    138138                                switch((int)errno) {

  • libcfa/src/concurrency/io/call.cfa.in

    r37b7d95 re7d6968  
    4747        #include "kernel/fwd.hfa"
    4848
    49         #if defined(CFA_HAVE_IOSQE_FIXED_FILE) && defined(CFA_HAVE_IOSQE_IO_DRAIN) && defined(CFA_HAVE_IOSQE_ASYNC)
    50                 #define REGULAR_FLAGS (IOSQE_FIXED_FILE | IOSQE_IO_DRAIN | IOSQE_ASYNC)
    51         #elif defined(CFA_HAVE_IOSQE_FIXED_FILE) && defined(CFA_HAVE_IOSQE_ASYNC)
    52                 #define REGULAR_FLAGS (IOSQE_FIXED_FILE | IOSQE_ASYNC)
    53         #elif defined(CFA_HAVE_IOSQE_FIXED_FILE) && defined(CFA_HAVE_IOSQE_IO_DRAIN)
    54                 #define REGULAR_FLAGS (IOSQE_FIXED_FILE | IOSQE_IO_DRAIN)
    55         #elif defined(CFA_HAVE_IOSQE_IO_DRAIN) && defined(CFA_HAVE_IOSQE_ASYNC)
    56                 #define REGULAR_FLAGS (IOSQE_IO_DRAIN | IOSQE_ASYNC)
    57         #elif defined(CFA_HAVE_IOSQE_FIXED_FILE)
    58                 #define REGULAR_FLAGS (IOSQE_FIXED_FILE)
    59         #elif defined(CFA_HAVE_IOSQE_IO_DRAIN)
    60                 #define REGULAR_FLAGS (IOSQE_IO_DRAIN)
    61         #elif defined(CFA_HAVE_IOSQE_ASYNC)
    62                 #define REGULAR_FLAGS (IOSQE_ASYNC)
    63         #else
    64                 #define REGULAR_FLAGS (0)
    65         #endif
    66 
    67         #if defined(CFA_HAVE_IOSQE_IO_LINK) && defined(CFA_HAVE_IOSQE_IO_HARDLINK)
    68                 #define LINK_FLAGS (IOSQE_IO_LINK | IOSQE_IO_HARDLINK)
    69         #elif defined(CFA_HAVE_IOSQE_IO_LINK)
    70                 #define LINK_FLAGS (IOSQE_IO_LINK)
    71         #elif defined(CFA_HAVE_IOSQE_IO_HARDLINK)
    72                 #define LINK_FLAGS (IOSQE_IO_HARDLINK)
    73         #else
    74                 #define LINK_FLAGS (0)
    75         #endif
    76 
    77         #if defined(CFA_HAVE_SPLICE_F_FD_IN_FIXED)
    78                 #define SPLICE_FLAGS (SPLICE_F_FD_IN_FIXED)
    79         #else
    80                 #define SPLICE_FLAGS (0)
    81         #endif
     49        static const __u8 REGULAR_FLAGS = 0
     50                #if defined(CFA_HAVE_IOSQE_FIXED_FILE)
     51                        | IOSQE_FIXED_FILE
     52                #endif
     53                #if defined(CFA_HAVE_IOSQE_IO_DRAIN)
     54                        | IOSQE_IO_DRAIN
     55                #endif
     56                #if defined(CFA_HAVE_IOSQE_ASYNC)
     57                        | IOSQE_ASYNC
     58                #endif
     59        ;
     60
     61        static const __u32 LINK_FLAGS = 0
     62                #if defined(CFA_HAVE_IOSQE_IO_LINK)
     63                        | IOSQE_IO_LINK
     64                #endif
     65                #if defined(CFA_HAVE_IOSQE_IO_HARDLINK)
     66                        | IOSQE_IO_HARDLINK
     67                #endif
     68        ;
     69
     70        static const __u32 SPLICE_FLAGS = 0
     71                #if defined(CFA_HAVE_SPLICE_F_FD_IN_FIXED)
     72                        | SPLICE_F_FD_IN_FIXED
     73                #endif
     74        ;
    8275
    8376        extern [* struct io_uring_sqe, __u32] __submit_alloc( struct __io_data & ring, __u64 data );

  • libcfa/src/concurrency/kernel.cfa

    r37b7d95 re7d6968  
    252252                /* paranoid */ verify( kernelTLS.this_thread == thrd_dst );
    253253                /* paranoid */ verify( thrd_dst->context.SP );
     254                /* paranoid */ verify( thrd_dst->state != Halted );
    254255                /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->curr_cor == proc_cor, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); // add escape condition if we are setting up the processor
    255256                /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->curr_cor == proc_cor, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); // add escape condition if we are setting up the processor
    … …  
    287288                if(unlikely(thrd_dst->state == Halted)) {
    288289                        // The thread has halted, it should never be scheduled/run again
    289                         // We may need to wake someone up here since
    290                         unpark( this->destroyer );
    291                         this->destroyer = 0p;
     290                        // finish the thread
     291                        __thread_finish( thrd_dst );
    292292                        break RUNNING;
    293293                }
    … …  
    448448}
    449449
    450 // KERNEL ONLY
    451 void __leave_thread() {
    452         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    453         returnToKernel();
    454         abort();
     450extern "C" {
     451        // Leave the thread monitor
     452        // last routine called by a thread.
     453        // Should never return
     454        void __cfactx_thrd_leave() {
     455                $thread * thrd = TL_GET( this_thread );
     456                $monitor * this = &thrd->self_mon;
     457
     458                // Lock the monitor now
     459                lock( this->lock __cfaabi_dbg_ctx2 );
     460
     461                disable_interrupts();
     462
     463                thrd->state = Halted;
     464
     465                if( thrd != this->owner || this->recursion != 1) { abort( "Thread internal monitor has unbalanced recursion" ); }
     466
     467                // Leave the thread
     468                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
     469                returnToKernel();
     470                abort();
     471
     472                // Control flow should never reach here!
     473        }
    455474}
    456475

  • libcfa/src/concurrency/kernel.hfa

    r37b7d95 re7d6968  
    7979        // Handle to pthreads
    8080        pthread_t kernel_thread;
    81 
    82         // RunThread data
    83         // Action to do after a thread is ran
    84         $thread * destroyer;
    8581
    8682        // Preemption data

  • libcfa/src/concurrency/kernel/startup.cfa

    r37b7d95 re7d6968  
    474474        this.cltr = &_cltr;
    475475        full_proc = true;
    476         destroyer = 0p;
    477476        do_terminate = false;
    478477        preemption_alarm = 0p;

  • libcfa/src/concurrency/kernel_private.hfa

    r37b7d95 re7d6968  
    3939;
    4040
    41 //Block current thread and release/wake-up the following resources
    42 void __leave_thread() __attribute__((noreturn));
     41//release/wake-up the following resources
     42void __thread_finish( $thread * thrd );
    4343
    4444//-----------------------------------------------------------------------------

  • libcfa/src/concurrency/monitor.cfa

    r37b7d95 re7d6968  
    281281}
    282282
    283 extern "C" {
    284         // Leave the thread monitor
    285         // last routine called by a thread.
    286         // Should never return
    287         void __cfactx_thrd_leave() {
    288                 $thread * thrd = TL_GET( this_thread );
    289                 $monitor * this = &thrd->self_mon;
    290 
    291                 // Lock the monitor now
    292                 lock( this->lock __cfaabi_dbg_ctx2 );
    293 
    294                 disable_interrupts();
    295 
    296                 thrd->state = Halted;
    297 
    298                 /* paranoid */ verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", thrd, this->owner, this->recursion, this );
    299 
    300                 // Leaving a recursion level, decrement the counter
    301                 this->recursion -= 1;
    302 
    303                 // If we haven't left the last level of recursion
    304                 // it must mean there is an error
    305                 if( this->recursion != 0) { abort( "Thread internal monitor has unbalanced recursion" ); }
    306 
    307                 // Fetch the next thread, can be null
    308                 $thread * new_owner = next_thread( this );
    309 
    310                 // Release the monitor lock
    311                 unlock( this->lock );
    312 
    313                 // Unpark the next owner if needed
    314                 /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
    315                 /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    316                 /* paranoid */ verify( ! kernelTLS.this_processor->destroyer );
    317                 /* paranoid */ verify( thrd->state == Halted );
    318 
    319                 kernelTLS.this_processor->destroyer = new_owner;
    320 
    321                 // Leave the thread
    322                 __leave_thread();
    323 
    324                 // Control flow should never reach here!
    325         }
     283void __thread_finish( $thread * thrd ) {
     284        $monitor * this = &thrd->self_mon;
     285
     286        // Lock the monitor now
     287        /* paranoid */ verify( this->lock.lock );
     288        /* paranoid */ verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", thrd, this->owner, this->recursion, this );
     289        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
     290        /* paranoid */ verify( thrd->state == Halted );
     291        /* paranoid */ verify( this->recursion == 1 );
     292
     293        // Leaving a recursion level, decrement the counter
     294        this->recursion -= 1;
     295        this->owner = 0p;
     296
     297        // Fetch the next thread, can be null
     298        $thread * new_owner = next_thread( this );
     299
     300        // Release the monitor lock
     301        unlock( this->lock );
     302
     303        // Unpark the next owner if needed
     304        /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
     305        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
     306        /* paranoid */ verify( thrd->state == Halted );
     307        unpark( new_owner );
    326308}
    327309

  • libcfa/src/concurrency/snzi.hfa

    r37b7d95 re7d6968  
    3636static inline void depart( __snzi_node_t & );
    3737
    38 #define __snzi_half -1
     38static const int __snzi_half = -1;
    3939
    4040//--------------------------------------------------

  • libcfa/src/exception.h

    r37b7d95 re7d6968  
    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

    r37b7d95 re7d6968  
    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
    … …  
    125125#define VTABLE_ASSERTION(exception_name, parameters) \
    126126        { VTABLE_TYPE(exception_name) parameters VTABLE_NAME(exception_name); }
     127
     128// IS_EXCEPTION(exception_name [, (...parameters)])
     129// IS_RESUMPTION_EXCEPTION(exception_name [, (parameters...)])
     130// IS_TERMINATION_EXCEPTION(exception_name [, (parameters...)])
     131// Create an assertion that exception_name, possibly with the qualifing parameters, is the given
     132// kind of exception with the standard vtable with the same parameters if applicable.
     133#define IS_EXCEPTION(...) _IS_EXCEPTION(is_exception, __VA_ARGS__, , ~)
     134#define IS_RESUMPTION_EXCEPTION(...) _IS_EXCEPTION(is_resumption_exception, __VA_ARGS__, , ~)
     135#define IS_TERMINATION_EXCEPTION(...) _IS_EXCEPTION(is_termination_exception, __VA_ARGS__, , ~)
    127136
    128137// All internal helper macros begin with an underscore.
    … …  
    160169
    161170#define _FORALL_CTOR0_DECLARATION(exception_name, assertions, parameters) \
    162         forall(_UNPACK assertions | VTABLE_ASSERTION(exception_name, parameters) ) \
     171        forall(_UNPACK assertions | \
     172                is_exception(exception_name parameters, VTABLE_TYPE(exception_name) parameters)) \
    163173        void ?{}(exception_name parameters & this)
    164174
    165175#define _FORALL_CTOR0_INSTANCE(exception_name, assertions, parameters) \
    166176        _FORALL_CTOR0_DECLARATION(exception_name, assertions, parameters) { \
    167                 VTABLE_INIT(this, exception_name); \
     177                (this).virtual_table = &get_exception_vtable(&this); \
    168178        }
    169179
    … …  
    185195#define _VTABLE_DECLARATION(exception_name, parent_name, ...) \
    186196        struct exception_name; \
    187         void mark_exception(exception_name *); \
    188197        VTABLE_TYPE(exception_name); \
     198        VTABLE_TYPE(exception_name) const & get_exception_vtable(exception_name *); \
    189199        extern VTABLE_TYPE(exception_name) VTABLE_NAME(exception_name); \
    190200        VTABLE_TYPE(exception_name) { \
    … …  
    197207
    198208#define _VTABLE_INSTANCE(exception_name, parent_name, ...) \
    199         void mark_exception(exception_name *) {} \
     209        VTABLE_TYPE(exception_name) const & get_exception_vtable(exception_name *) { \
     210                return VTABLE_NAME(exception_name); \
     211        } \
    200212        void _GLUE2(exception_name,_copy)(exception_name * this, exception_name * other) { \
    201213                *this = *other; \
    … …  
    218230
    219231#define _POLY_VTABLE_INSTANCE(exception_name, parent_name, ...) \
    220         void mark_exception(exception_name(__VA_ARGS__) *) {} \
     232        extern VTABLE_TYPE(exception_name)(__VA_ARGS__) VTABLE_NAME(exception_name); \
     233        VTABLE_TYPE(exception_name)(__VA_ARGS__) const & get_exception_vtable( \
     234                        exception_name(__VA_ARGS__) *) { \
     235                return VTABLE_NAME(exception_name); \
     236        } \
    221237        void _GLUE2(exception_name,_copy)( \
    222238                        exception_name(__VA_ARGS__) * this, exception_name(__VA_ARGS__) * other) { \
    … …  
    227243                _GLUE2(exception_name,_copy), ^?{}, \
    228244                _CLOSE
     245
     246#define _IS_EXCEPTION(kind, exception_name, parameters, ...) \
     247        kind(exception_name parameters, VTABLE_TYPE(exception_name) parameters)

  • libcfa/src/limits.cfa

    r37b7d95 re7d6968  
    1010// Created On       : Wed Apr  6 18:06:52 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Sep 30 22:56:32 2020
    13 // Update Count     : 76
     12// Last Modified On : Thu Mar  1 16:22:51 2018
     13// Update Count     : 74
    1414//
    1515
    … …  
    2323// Integral Constants
    2424
    25 signed char MIN = SCHAR_MIN;
    26 unsigned char MIN = 0;
    27 short int MIN = SHRT_MIN;
    28 unsigned short int MIN = 0;
    29 int MIN = INT_MIN;
    30 unsigned int MIN = 0;
    31 long int MIN = LONG_MIN;
    32 unsigned long int MIN = 0;
    33 long long int MIN = LLONG_MIN;
    34 unsigned long long int MIN = 0;
     25const signed char MIN = SCHAR_MIN;
     26const unsigned char MIN = 0;
     27const short int MIN = SHRT_MIN;
     28const unsigned short int MIN = 0;
     29const int MIN = INT_MIN;
     30const unsigned int MIN = 0;
     31const long int MIN = LONG_MIN;
     32const unsigned long int MIN = 0;
     33const long long int MIN = LLONG_MIN;
     34const unsigned long long int MIN = 0;
    3535
    36 signed char MAX = SCHAR_MAX;
    37 unsigned char MAX = UCHAR_MAX;
    38 short int MAX = SHRT_MAX;
    39 unsigned short int MAX = USHRT_MAX;
    40 int MAX = INT_MAX;
    41 unsigned int MAX = UINT_MAX;
    42 long int MAX = LONG_MAX;
    43 unsigned long int MAX = ULONG_MAX;
    44 long long int MAX = LLONG_MAX;
    45 unsigned long long int MAX = ULLONG_MAX;
     36const signed char MAX = SCHAR_MAX;
     37const unsigned char MAX = UCHAR_MAX;
     38const short int MAX = SHRT_MAX;
     39const unsigned short int MAX = USHRT_MAX;
     40const int MAX = INT_MAX;
     41const unsigned int MAX = UINT_MAX;
     42const long int MAX = LONG_MAX;
     43const unsigned long int MAX = ULONG_MAX;
     44const long long int MAX = LLONG_MAX;
     45const unsigned long long int MAX = ULLONG_MAX;
    4646
    4747// Floating-Point Constants
    4848
    49 float MIN = FLT_MIN;
    50 double MIN = DBL_MIN;
    51 long double MIN = LDBL_MIN;
    52 float _Complex MIN = __FLT_MIN__ + __FLT_MIN__ * I;
    53 double _Complex MIN = DBL_MIN +  DBL_MIN * I;
    54 long double _Complex MIN = LDBL_MIN + LDBL_MIN * I;
     49const float MIN = FLT_MIN;
     50const double MIN = DBL_MIN;
     51const long double MIN = LDBL_MIN;
     52const float _Complex MIN = __FLT_MIN__ + __FLT_MIN__ * I;
     53const double _Complex MIN = DBL_MIN +  DBL_MIN * I;
     54const long double _Complex MIN = LDBL_MIN + LDBL_MIN * I;
    5555
    56 float MAX = FLT_MAX;
    57 double MAX = DBL_MAX;
    58 long double MAX = LDBL_MAX;
    59 float _Complex MAX = FLT_MAX + FLT_MAX * I;
    60 double _Complex MAX = DBL_MAX + DBL_MAX * I;
    61 long double _Complex MAX = LDBL_MAX + LDBL_MAX * I;
     56const float MAX = FLT_MAX;
     57const double MAX = DBL_MAX;
     58const long double MAX = LDBL_MAX;
     59const float _Complex MAX = FLT_MAX + FLT_MAX * I;
     60const double _Complex MAX = DBL_MAX + DBL_MAX * I;
     61const long double _Complex MAX = LDBL_MAX + LDBL_MAX * I;
    6262
    63 float PI = (float)M_PI;                                                                 // pi
    64 float PI_2 = (float)M_PI_2;                                                             // pi / 2
    65 float PI_4 = (float)M_PI_4;                                                             // pi / 4
    66 float _1_PI = (float)M_1_PI;                                                    // 1 / pi
    67 float _2_PI = (float)M_2_PI;                                                    // 2 / pi
    68 float _2_SQRT_PI = (float)M_2_SQRTPI;                                   // 2 / sqrt(pi)
     63const float PI = (float)M_PI;                                                   // pi
     64const float PI_2 = (float)M_PI_2;                                               // pi / 2
     65const float PI_4 = (float)M_PI_4;                                               // pi / 4
     66const float _1_PI = (float)M_1_PI;                                              // 1 / pi
     67const float _2_PI = (float)M_2_PI;                                              // 2 / pi
     68const float _2_SQRT_PI = (float)M_2_SQRTPI;                             // 2 / sqrt(pi)
    6969
    70 double PI = M_PI;                                                                               // pi
    71 double PI_2 = M_PI_2;                                                                   // pi / 2
    72 double PI_4 = M_PI_4;                                                                   // pi / 4
    73 double _1_PI = M_1_PI;                                                                  // 1 / pi
    74 double _2_PI = M_2_PI;                                                                  // 2 / pi
    75 double _2_SQRT_PI = M_2_SQRTPI;                                                 // 2 / sqrt(pi)
     70const double PI = M_PI;                                                                 // pi
     71const double PI_2 = M_PI_2;                                                             // pi / 2
     72const double PI_4 = M_PI_4;                                                             // pi / 4
     73const double _1_PI = M_1_PI;                                                    // 1 / pi
     74const double _2_PI = M_2_PI;                                                    // 2 / pi
     75const double _2_SQRT_PI = M_2_SQRTPI;                                   // 2 / sqrt(pi)
    7676
    77 long double PI = M_PIl;                                                                 // pi
    78 long double PI_2 = M_PI_2l;                                                             // pi / 2
    79 long double PI_4 = M_PI_4l;                                                             // pi / 4
    80 long double _1_PI = M_1_PIl;                                                    // 1 / pi
    81 long double _2_PI = M_2_PIl;                                                    // 2 / pi
    82 long double _2_SQRT_PI = M_2_SQRTPIl;                                   // 2 / sqrt(pi)
     77const long double PI = M_PIl;                                                   // pi
     78const long double PI_2 = M_PI_2l;                                               // pi / 2
     79const long double PI_4 = M_PI_4l;                                               // pi / 4
     80const long double _1_PI = M_1_PIl;                                              // 1 / pi
     81const long double _2_PI = M_2_PIl;                                              // 2 / pi
     82const long double _2_SQRT_PI = M_2_SQRTPIl;                             // 2 / sqrt(pi)
    8383
    84 float _Complex PI = (float)M_PI + 0.0_iF;                               // pi
    85 float _Complex PI_2 = (float)M_PI_2 + 0.0_iF;                   // pi / 2
    86 float _Complex PI_4 = (float)M_PI_4 + 0.0_iF;                   // pi / 4
    87 float _Complex _1_PI = (float)M_1_PI + 0.0_iF;                  // 1 / pi
    88 float _Complex _2_PI = (float)M_2_PI + 0.0_iF;                  // 2 / pi
    89 float _Complex _2_SQRT_PI = (float)M_2_SQRTPI + 0.0_iF; // 2 / sqrt(pi)
     84const float _Complex PI = (float)M_PI + 0.0_iF;                 // pi
     85const float _Complex PI_2 = (float)M_PI_2 + 0.0_iF;             // pi / 2
     86const float _Complex PI_4 = (float)M_PI_4 + 0.0_iF;             // pi / 4
     87const float _Complex _1_PI = (float)M_1_PI + 0.0_iF;    // 1 / pi
     88const float _Complex _2_PI = (float)M_2_PI + 0.0_iF;    // 2 / pi
     89const float _Complex _2_SQRT_PI = (float)M_2_SQRTPI + 0.0_iF; // 2 / sqrt(pi)
    9090
    91 double _Complex PI = M_PI + 0.0_iD;                                             // pi
    92 double _Complex PI_2 = M_PI_2 + 0.0_iD;                                 // pi / 2
    93 double _Complex PI_4 = M_PI_4 + 0.0_iD;                                 // pi / 4
    94 double _Complex _1_PI = M_1_PI + 0.0_iD;                                // 1 / pi
    95 double _Complex _2_PI = M_2_PI + 0.0_iD;                                // 2 / pi
    96 double _Complex _2_SQRT_PI = M_2_SQRTPI + 0.0_iD;               // 2 / sqrt(pi)
     91const double _Complex PI = M_PI + 0.0_iD;                               // pi
     92const double _Complex PI_2 = M_PI_2 + 0.0_iD;                   // pi / 2
     93const double _Complex PI_4 = M_PI_4 + 0.0_iD;                   // pi / 4
     94const double _Complex _1_PI = M_1_PI + 0.0_iD;                  // 1 / pi
     95const double _Complex _2_PI = M_2_PI + 0.0_iD;                  // 2 / pi
     96const double _Complex _2_SQRT_PI = M_2_SQRTPI + 0.0_iD; // 2 / sqrt(pi)
    9797
    98 long double _Complex PI = M_PIl + 0.0_iL;                               // pi
    99 long double _Complex PI_2 = M_PI_2l + 0.0_iL;                   // pi / 2
    100 long double _Complex PI_4 = M_PI_4l + 0.0_iL;                   // pi / 4
    101 long double _Complex _1_PI = M_1_PIl + 0.0_iL;                  // 1 / pi
    102 long double _Complex _2_PI = M_2_PIl + 0.0_iL;                  // 2 / pi
    103 long double _Complex _2_SQRT_PI = M_2_SQRTPIl + 0.0_iL; // 2 / sqrt(pi)
     98const long double _Complex PI = M_PIl + 0.0_iL;                 // pi
     99const long double _Complex PI_2 = M_PI_2l + 0.0_iL;             // pi / 2
     100const long double _Complex PI_4 = M_PI_4l + 0.0_iL;             // pi / 4
     101const long double _Complex _1_PI = M_1_PIl + 0.0_iL;    // 1 / pi
     102const long double _Complex _2_PI = M_2_PIl + 0.0_iL;    // 2 / pi
     103const long double _Complex _2_SQRT_PI = M_2_SQRTPIl + 0.0_iL; // 2 / sqrt(pi)
    104104
    105 float E = (float)M_E;                                                                   // e
    106 float LOG2_E = (float)M_LOG2E;                                                  // log_2(e)
    107 float LOG10_E = (float)M_LOG10E;                                                // log_10(e)
    108 float LN_2 = (float)M_LN2;                                                              // log_e(2)
    109 float LN_10 = (float)M_LN10;                                                    // log_e(10)
    110 float SQRT_2 = (float)M_SQRT2;                                                  // sqrt(2)
    111 float _1_SQRT_2 = (float)M_SQRT1_2;                                             // 1 / sqrt(2)
     105const float E = (float)M_E;                                                             // e
     106const float LOG2_E = (float)M_LOG2E;                                    // log_2(e)
     107const float LOG10_E = (float)M_LOG10E;                                  // log_10(e)
     108const float LN_2 = (float)M_LN2;                                                // log_e(2)
     109const float LN_10 = (float)M_LN10;                                              // log_e(10)
     110const float SQRT_2 = (float)M_SQRT2;                                    // sqrt(2)
     111const float _1_SQRT_2 = (float)M_SQRT1_2;                               // 1 / sqrt(2)
    112112
    113 double E = M_E;                                                                                 // e
    114 double LOG2_E = M_LOG2E;                                                                // log_2(e)
    115 double LOG10_E = M_LOG10E;                                                              // log_10(e)
    116 double LN_2 = M_LN2;                                                                    // log_e(2)
    117 double LN_10 = M_LN10;                                                                  // log_e(10)
    118 double SQRT_2 = M_SQRT2;                                                                // sqrt(2)
    119 double _1_SQRT_2 = M_SQRT1_2;                                                   // 1 / sqrt(2)
     113const double E = M_E;                                                                   // e
     114const double LOG2_E = M_LOG2E;                                                  // log_2(e)
     115const double LOG10_E = M_LOG10E;                                                // log_10(e)
     116const double LN_2 = M_LN2;                                                              // log_e(2)
     117const double LN_10 = M_LN10;                                                    // log_e(10)
     118const double SQRT_2 = M_SQRT2;                                                  // sqrt(2)
     119const double _1_SQRT_2 = M_SQRT1_2;                                             // 1 / sqrt(2)
    120120
    121 long double E = M_El;                                                                   // e
    122 long double LOG2_E = M_LOG2El;                                                  // log_2(e)
    123 long double LOG10_E = M_LOG10El;                                                // log_10(e)
    124 long double LN_2 = M_LN2l;                                                              // log_e(2)
    125 long double LN_10 = M_LN10l;                                                    // log_e(10)
    126 long double SQRT_2 = M_SQRT2l;                                                  // sqrt(2)
    127 long double _1_SQRT_2 = M_SQRT1_2l;                                             // 1 / sqrt(2)
     121const long double E = M_El;                                                             // e
     122const long double LOG2_E = M_LOG2El;                                    // log_2(e)
     123const long double LOG10_E = M_LOG10El;                                  // log_10(e)
     124const long double LN_2 = M_LN2l;                                                // log_e(2)
     125const long double LN_10 = M_LN10l;                                              // log_e(10)
     126const long double SQRT_2 = M_SQRT2l;                                    // sqrt(2)
     127const long double _1_SQRT_2 = M_SQRT1_2l;                               // 1 / sqrt(2)
    128128
    129 float _Complex E = M_E + 0.0_iF;                                                // e
    130 float _Complex LOG2_E = M_LOG2E + 0.0_iF;                               // log_2(e)
    131 float _Complex LOG10_E = M_LOG10E + 0.0_iF;                             // log_10(e)
    132 float _Complex LN_2 = M_LN2 + 0.0_iF;                                   // log_e(2)
    133 float _Complex LN_10 = M_LN10 + 0.0_iF;                                 // log_e(10)
    134 float _Complex SQRT_2 = M_SQRT2 + 0.0_iF;                               // sqrt(2)
    135 float _Complex _1_SQRT_2 = M_SQRT1_2 + 0.0_iF;                  // 1 / sqrt(2)
     129const float _Complex E = M_E + 0.0_iF;                                  // e
     130const float _Complex LOG2_E = M_LOG2E + 0.0_iF;                 // log_2(e)
     131const float _Complex LOG10_E = M_LOG10E + 0.0_iF;               // log_10(e)
     132const float _Complex LN_2 = M_LN2 + 0.0_iF;                             // log_e(2)
     133const float _Complex LN_10 = M_LN10 + 0.0_iF;                   // log_e(10)
     134const float _Complex SQRT_2 = M_SQRT2 + 0.0_iF;                 // sqrt(2)
     135const float _Complex _1_SQRT_2 = M_SQRT1_2 + 0.0_iF;    // 1 / sqrt(2)
    136136
    137 double _Complex E = M_E + 0.0_iD;                                               // e
    138 double _Complex LOG2_E = M_LOG2E + 0.0_iD;                              // log_2(e)
    139 double _Complex LOG10_E = M_LOG10E + 0.0_iD;                    // log_10(e)
    140 double _Complex LN_2 = M_LN2 + 0.0_iD;                                  // log_e(2)
    141 double _Complex LN_10 = M_LN10 + 0.0_iD;                                // log_e(10)
    142 double _Complex SQRT_2 = M_SQRT2 + 0.0_iD;                              // sqrt(2)
    143 double _Complex _1_SQRT_2 = M_SQRT1_2 + 0.0_iD;                 // 1 / sqrt(2)
     137const double _Complex E = M_E + 0.0_iD;                                 // e
     138const double _Complex LOG2_E = M_LOG2E + 0.0_iD;                // log_2(e)
     139const double _Complex LOG10_E = M_LOG10E + 0.0_iD;              // log_10(e)
     140const double _Complex LN_2 = M_LN2 + 0.0_iD;                    // log_e(2)
     141const double _Complex LN_10 = M_LN10 + 0.0_iD;                  // log_e(10)
     142const double _Complex SQRT_2 = M_SQRT2 + 0.0_iD;                // sqrt(2)
     143const double _Complex _1_SQRT_2 = M_SQRT1_2 + 0.0_iD;   // 1 / sqrt(2)
    144144
    145 long double _Complex E = M_El + 0.0_iL;                                 // e
    146 long double _Complex LOG2_E = M_LOG2El + 0.0_iL;                // log_2(e)
    147 long double _Complex LOG10_E = M_LOG10El + 0.0_iL;              // log_10(e)
    148 long double _Complex LN_2 = M_LN2l + 0.0_iL;                    // log_e(2)
    149 long double _Complex LN_10 = M_LN10l + 0.0_iL;                  // log_e(10)
    150 long double _Complex SQRT_2 = M_SQRT2l + 0.0_iL;                // sqrt(2)
    151 long double _Complex _1_SQRT_2 = M_SQRT1_2l + 0.0_iL;   // 1 / sqrt(2)
     145const long double _Complex E = M_El + 0.0_iL;                   // e
     146const long double _Complex LOG2_E = M_LOG2El + 0.0_iL;  // log_2(e)
     147const long double _Complex LOG10_E = M_LOG10El + 0.0_iL; // log_10(e)
     148const long double _Complex LN_2 = M_LN2l + 0.0_iL;              // log_e(2)
     149const long double _Complex LN_10 = M_LN10l + 0.0_iL;    // log_e(10)
     150const long double _Complex SQRT_2 = M_SQRT2l + 0.0_iL;  // sqrt(2)
     151const long double _Complex _1_SQRT_2 = M_SQRT1_2l + 0.0_iL; // 1 / sqrt(2)
    152152
    153153// Local Variables: //

  • libcfa/src/limits.hfa

    r37b7d95 re7d6968  
    1010// Created On       : Wed Apr  6 18:06:52 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Sep 30 22:56:35 2020
    13 // Update Count     : 15
     12// Last Modified On : Thu Mar  1 16:20:54 2018
     13// Update Count     : 13
    1414//
    1515
    … …  
    1818// Integral Constants
    1919
    20 extern signed char MIN;
    21 extern unsigned char MIN;
    22 extern short int MIN;
    23 extern unsigned short int MIN;
    24 extern int MIN;
    25 extern unsigned int MIN;
    26 extern long int MIN;
    27 extern unsigned long int MIN;
    28 extern long long int MIN;
    29 extern unsigned long long int MIN;
     20extern const signed char MIN;
     21extern const unsigned char MIN;
     22extern const short int MIN;
     23extern const unsigned short int MIN;
     24extern const int MIN;
     25extern const unsigned int MIN;
     26extern const long int MIN;
     27extern const unsigned long int MIN;
     28extern const long long int MIN;
     29extern const unsigned long long int MIN;
    3030
    31 extern signed char MAX;
    32 extern unsigned char MAX;
    33 extern short int MAX;
    34 extern unsigned short int MAX;
    35 extern int MAX;
    36 extern unsigned int MAX;
    37 extern long int MAX;
    38 extern unsigned long int MAX;
    39 extern long long int MAX;
    40 extern unsigned long long int MAX;
     31extern const signed char MAX;
     32extern const unsigned char MAX;
     33extern const short int MAX;
     34extern const unsigned short int MAX;
     35extern const int MAX;
     36extern const unsigned int MAX;
     37extern const long int MAX;
     38extern const unsigned long int MAX;
     39extern const long long int MAX;
     40extern const unsigned long long int MAX;
    4141
    4242// Floating-Point Constants
    4343
    44 extern float MIN;
    45 extern double MIN;
    46 extern long double MIN;
    47 extern float _Complex MIN;
    48 extern double _Complex MIN;
    49 extern long double _Complex MIN;
     44extern const float MIN;
     45extern const double MIN;
     46extern const long double MIN;
     47extern const float _Complex MIN;
     48extern const double _Complex MIN;
     49extern const long double _Complex MIN;
    5050
    51 extern float MAX;
    52 extern double MAX;
    53 extern long double MAX;
    54 extern float _Complex MAX;
    55 extern double _Complex MAX;
    56 extern long double _Complex MAX;
     51extern const float MAX;
     52extern const double MAX;
     53extern const long double MAX;
     54extern const float _Complex MAX;
     55extern const double _Complex MAX;
     56extern const long double _Complex MAX;
    5757
    58 extern float PI;                                                                                // pi
    59 extern float PI_2;                                                                              // pi / 2
    60 extern float PI_4;                                                                              // pi / 4
    61 extern float _1_PI;                                                                             // 1 / pi
    62 extern float _2_PI;                                                                             // 2 / pi
    63 extern float _2_SQRT_PI;                                                                // 2 / sqrt(pi)
     58extern const float PI;                                                                  // pi
     59extern const float PI_2;                                                                // pi / 2
     60extern const float PI_4;                                                                // pi / 4
     61extern const float _1_PI;                                                               // 1 / pi
     62extern const float _2_PI;                                                               // 2 / pi
     63extern const float _2_SQRT_PI;                                                  // 2 / sqrt(pi)
    6464
    65 extern double PI;                                                                               // pi
    66 extern double PI_2;                                                                             // pi / 2
    67 extern double PI_4;                                                                             // pi / 4
    68 extern double _1_PI;                                                                    // 1 / pi
    69 extern double _2_PI;                                                                    // 2 / pi
    70 extern double _2_SQRT_PI;                                                               // 2 / sqrt(pi)
     65extern const double PI;                                                                 // pi
     66extern const double PI_2;                                                               // pi / 2
     67extern const double PI_4;                                                               // pi / 4
     68extern const double _1_PI;                                                              // 1 / pi
     69extern const double _2_PI;                                                              // 2 / pi
     70extern const double _2_SQRT_PI;                                                 // 2 / sqrt(pi)
    7171
    72 extern long double PI;                                                                  // pi
    73 extern long double PI_2;                                                                // pi / 2
    74 extern long double PI_4;                                                                // pi / 4
    75 extern long double _1_PI;                                                               // 1 / pi
    76 extern long double _2_PI;                                                               // 2 / pi
    77 extern long double _2_SQRT_PI;                                                  // 2 / sqrt(pi)
     72extern const long double PI;                                                    // pi
     73extern const long double PI_2;                                                  // pi / 2
     74extern const long double PI_4;                                                  // pi / 4
     75extern const long double _1_PI;                                                 // 1 / pi
     76extern const long double _2_PI;                                                 // 2 / pi
     77extern const long double _2_SQRT_PI;                                    // 2 / sqrt(pi)
    7878
    79 extern float _Complex PI;                                                               // pi
    80 extern float _Complex PI_2;                                                             // pi / 2
    81 extern float _Complex PI_4;                                                             // pi / 4
    82 extern float _Complex _1_PI;                                                    // 1 / pi
    83 extern float _Complex _2_PI;                                                    // 2 / pi
    84 extern float _Complex _2_SQRT_PI;                                               // 2 / sqrt(pi)
     79extern const float _Complex PI;                                                 // pi
     80extern const float _Complex PI_2;                                               // pi / 2
     81extern const float _Complex PI_4;                                               // pi / 4
     82extern const float _Complex _1_PI;                                              // 1 / pi
     83extern const float _Complex _2_PI;                                              // 2 / pi
     84extern const float _Complex _2_SQRT_PI;                                 // 2 / sqrt(pi)
    8585
    86 extern double _Complex PI;                                                              // pi
    87 extern double _Complex PI_2;                                                    // pi / 2
    88 extern double _Complex PI_4;                                                    // pi / 4
    89 extern double _Complex _1_PI;                                                   // 1 / pi
    90 extern double _Complex _2_PI;                                                   // 2 / pi
    91 extern double _Complex _2_SQRT_PI;                                              // 2 / sqrt(pi)
     86extern const double _Complex PI;                                                // pi
     87extern const double _Complex PI_2;                                              // pi / 2
     88extern const double _Complex PI_4;                                              // pi / 4
     89extern const double _Complex _1_PI;                                             // 1 / pi
     90extern const double _Complex _2_PI;                                             // 2 / pi
     91extern const double _Complex _2_SQRT_PI;                                // 2 / sqrt(pi)
    9292
    93 extern long double _Complex PI;                                                 // pi
    94 extern long double _Complex PI_2;                                               // pi / 2
    95 extern long double _Complex PI_4;                                               // pi / 4
    96 extern long double _Complex _1_PI;                                              // 1 / pi
    97 extern long double _Complex _2_PI;                                              // 2 / pi
    98 extern long double _Complex _2_SQRT_PI;                                 // 2 / sqrt(pi)
     93extern const long double _Complex PI;                                   // pi
     94extern const long double _Complex PI_2;                                 // pi / 2
     95extern const long double _Complex PI_4;                                 // pi / 4
     96extern const long double _Complex _1_PI;                                // 1 / pi
     97extern const long double _Complex _2_PI;                                // 2 / pi
     98extern const long double _Complex _2_SQRT_PI;                   // 2 / sqrt(pi)
    9999
    100 extern float E;                                                                                 // e
    101 extern float LOG2_E;                                                                    // log_2(e)
    102 extern float LOG10_E;                                                                   // log_10(e)
    103 extern float LN_2;                                                                              // log_e(2)
    104 extern float LN_10;                                                                             // log_e(10)
    105 extern float SQRT_2;                                                                    // sqrt(2)
    106 extern float _1_SQRT_2;                                                                 // 1 / sqrt(2)
     100extern const float E;                                                                   // e
     101extern const float LOG2_E;                                                              // log_2(e)
     102extern const float LOG10_E;                                                             // log_10(e)
     103extern const float LN_2;                                                                // log_e(2)
     104extern const float LN_10;                                                               // log_e(10)
     105extern const float SQRT_2;                                                              // sqrt(2)
     106extern const float _1_SQRT_2;                                                   // 1 / sqrt(2)
    107107
    108 extern double E;                                                                                // e
    109 extern double LOG2_E;                                                                   // log_2(e)
    110 extern double LOG10_E;                                                                  // log_10(e)
    111 extern double LN_2;                                                                             // log_e(2)
    112 extern double LN_10;                                                                    // log_e(10)
    113 extern double SQRT_2;                                                                   // sqrt(2)
    114 extern double _1_SQRT_2;                                                                // 1 / sqrt(2)
     108extern const double E;                                                                  // e
     109extern const double LOG2_E;                                                             // log_2(e)
     110extern const double LOG10_E;                                                    // log_10(e)
     111extern const double LN_2;                                                               // log_e(2)
     112extern const double LN_10;                                                              // log_e(10)
     113extern const double SQRT_2;                                                             // sqrt(2)
     114extern const double _1_SQRT_2;                                                  // 1 / sqrt(2)
    115115
    116 extern long double E;                                                                   // e
    117 extern long double LOG2_E;                                                              // log_2(e)
    118 extern long double LOG10_E;                                                             // log_10(e)
    119 extern long double LN_2;                                                                // log_e(2)
    120 extern long double LN_10;                                                               // log_e(10)
    121 extern long double SQRT_2;                                                              // sqrt(2)
    122 extern long double _1_SQRT_2;                                                   // 1/sqrt(2)
     116extern const long double E;                                                             // e
     117extern const long double LOG2_E;                                                // log_2(e)
     118extern const long double LOG10_E;                                               // log_10(e)
     119extern const long double LN_2;                                                  // log_e(2)
     120extern const long double LN_10;                                                 // log_e(10)
     121extern const long double SQRT_2;                                                // sqrt(2)
     122extern const long double _1_SQRT_2;                                             // 1/sqrt(2)
    123123
    124 extern float _Complex E;                                                                // e
    125 extern float _Complex LOG2_E;                                                   // log_2(e)
    126 extern float _Complex LOG10_E;                                                  // log_10(e)
    127 extern float _Complex LN_2;                                                             // log_e(2)
    128 extern float _Complex LN_10;                                                    // log_e(10)
    129 extern float _Complex SQRT_2;                                                   // sqrt(2)
    130 extern float _Complex _1_SQRT_2;                                                // 1 / sqrt(2)
     124extern const float _Complex E;                                                  // e
     125extern const float _Complex LOG2_E;                                             // log_2(e)
     126extern const float _Complex LOG10_E;                                    // log_10(e)
     127extern const float _Complex LN_2;                                               // log_e(2)
     128extern const float _Complex LN_10;                                              // log_e(10)
     129extern const float _Complex SQRT_2;                                             // sqrt(2)
     130extern const float _Complex _1_SQRT_2;                                  // 1 / sqrt(2)
    131131
    132 extern double _Complex E;                                                               // e
    133 extern double _Complex LOG2_E;                                                  // log_2(e)
    134 extern double _Complex LOG10_E;                                                 // log_10(e)
    135 extern double _Complex LN_2;                                                    // log_e(2)
    136 extern double _Complex LN_10;                                                   // log_e(10)
    137 extern double _Complex SQRT_2;                                                  // sqrt(2)
    138 extern double _Complex _1_SQRT_2;                                               // 1 / sqrt(2)
     132extern const double _Complex E;                                                 // e
     133extern const double _Complex LOG2_E;                                    // log_2(e)
     134extern const double _Complex LOG10_E;                                   // log_10(e)
     135extern const double _Complex LN_2;                                              // log_e(2)
     136extern const double _Complex LN_10;                                             // log_e(10)
     137extern const double _Complex SQRT_2;                                    // sqrt(2)
     138extern const double _Complex _1_SQRT_2;                                 // 1 / sqrt(2)
    139139
    140 extern long double _Complex E;                                                  // e
    141 extern long double _Complex LOG2_E;                                             // log_2(e)
    142 extern long double _Complex LOG10_E;                                    // log_10(e)
    143 extern long double _Complex LN_2;                                               // log_e(2)
    144 extern long double _Complex LN_10;                                              // log_e(10)
    145 extern long double _Complex SQRT_2;                                             // sqrt(2)
    146 extern long double _Complex _1_SQRT_2;                                  // 1 / sqrt(2)
     140extern const long double _Complex E;                                    // e
     141extern const long double _Complex LOG2_E;                               // log_2(e)
     142extern const long double _Complex LOG10_E;                              // log_10(e)
     143extern const long double _Complex LN_2;                                 // log_e(2)
     144extern const long double _Complex LN_10;                                // log_e(10)
     145extern const long double _Complex SQRT_2;                               // sqrt(2)
     146extern const long double _Complex _1_SQRT_2;                    // 1 / sqrt(2)
    147147
    148148// Local Variables: //

  • src/AST/Expr.cpp

    r37b7d95 re7d6968  
    102102        }
    103103        return ret;
     104}
     105
     106// --- VariableExpr
     107
     108VariableExpr::VariableExpr( const CodeLocation & loc )
     109: Expr( loc ), var( nullptr ) {}
     110
     111VariableExpr::VariableExpr( const CodeLocation & loc, const DeclWithType * v )
     112: Expr( loc ), var( v ) {
     113        assert( var );
     114        assert( var->get_type() );
     115        result = shallowCopy( var->get_type() );
     116}
     117
     118bool VariableExpr::get_lvalue() const {
     119        // It isn't always an lvalue, but it is never an rvalue.
     120        return true;
     121}
     122
     123VariableExpr * VariableExpr::functionPointer(
     124                const CodeLocation & loc, const FunctionDecl * decl ) {
     125        // wrap usually-determined result type in a pointer
     126        VariableExpr * funcExpr = new VariableExpr{ loc, decl };
     127        funcExpr->result = new PointerType{ funcExpr->result };
     128        return funcExpr;
    104129}
    105130
    … …  
    238263}
    239264
    240 // --- VariableExpr
    241 
    242 VariableExpr::VariableExpr( const CodeLocation & loc )
    243 : Expr( loc ), var( nullptr ) {}
    244 
    245 VariableExpr::VariableExpr( const CodeLocation & loc, const DeclWithType * v )
    246 : Expr( loc ), var( v ) {
    247         assert( var );
    248         assert( var->get_type() );
    249         result = shallowCopy( var->get_type() );
    250 }
    251 
    252 bool VariableExpr::get_lvalue() const {
    253         // It isn't always an lvalue, but it is never an rvalue.
    254         return true;
    255 }
    256 
    257 VariableExpr * VariableExpr::functionPointer(
    258                 const CodeLocation & loc, const FunctionDecl * decl ) {
    259         // wrap usually-determined result type in a pointer
    260         VariableExpr * funcExpr = new VariableExpr{ loc, decl };
    261         funcExpr->result = new PointerType{ funcExpr->result };
    262         return funcExpr;
    263 }
    264 
    265265// --- ConstantExpr
    266266

  • src/AST/Expr.hpp

    r37b7d95 re7d6968  
    250250};
    251251
     252/// A reference to a named variable.
     253class VariableExpr final : public Expr {
     254public:
     255        readonly<DeclWithType> var;
     256
     257        VariableExpr( const CodeLocation & loc );
     258        VariableExpr( const CodeLocation & loc, const DeclWithType * v );
     259
     260        bool get_lvalue() const final;
     261
     262        /// generates a function pointer for a given function
     263        static VariableExpr * functionPointer( const CodeLocation & loc, const FunctionDecl * decl );
     264
     265        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     266private:
     267        VariableExpr * clone() const override { return new VariableExpr{ *this }; }
     268        MUTATE_FRIEND
     269};
     270
    252271/// Address-of expression `&e`
    253272class AddressExpr final : public Expr {
    … …  
    390409        friend class ::ConverterOldToNew;
    391410        friend class ::ConverterNewToOld;
    392 };
    393 
    394 /// A reference to a named variable.
    395 class VariableExpr final : public Expr {
    396 public:
    397         readonly<DeclWithType> var;
    398 
    399         VariableExpr( const CodeLocation & loc );
    400         VariableExpr( const CodeLocation & loc, const DeclWithType * v );
    401 
    402         bool get_lvalue() const final;
    403 
    404         /// generates a function pointer for a given function
    405         static VariableExpr * functionPointer( const CodeLocation & loc, const FunctionDecl * decl );
    406 
    407         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
    408 private:
    409         VariableExpr * clone() const override { return new VariableExpr{ *this }; }
    410         MUTATE_FRIEND
    411411};
    412412

  • src/AST/Type.cpp

    r37b7d95 re7d6968  
    157157
    158158template<typename decl_t>
     159SueInstType<decl_t>::SueInstType(
     160        const base_type * b, std::vector<ptr<Expr>> && params,
     161        CV::Qualifiers q, std::vector<ptr<Attribute>> && as )
     162: BaseInstType( b->name, std::move(params), q, std::move(as) ), base( b ) {}
     163
     164template<typename decl_t>
    159165bool SueInstType<decl_t>::isComplete() const {
    160166        return base ? base->body : false;

  • src/AST/Type.hpp

    r37b7d95 re7d6968  
    302302class FunctionType final : public ParameterizedType {
    303303public:
    304 //      std::vector<ptr<DeclWithType>> returns;
    305 //      std::vector<ptr<DeclWithType>> params;
    306 
    307304        std::vector<ptr<Type>> returns;
    308305        std::vector<ptr<Type>> params;
    … …  
    345342        : ParameterizedType(q, std::move(as)), params(), name(n) {}
    346343
     344        BaseInstType(
     345                const std::string& n, std::vector<ptr<Expr>> && params,
     346                CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
     347        : ParameterizedType(q, std::move(as)), params(std::move(params)), name(n) {}
     348
    347349        BaseInstType( const BaseInstType & o );
    348350
    … …  
    369371
    370372        SueInstType(
    371                 const decl_t * b, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
     373                const base_type * b, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
     374
     375        SueInstType(
     376                const base_type * b, std::vector<ptr<Expr>> && params,
     377                CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
    372378
    373379        bool isComplete() const override;

  • src/AST/porting.md

    r37b7d95 re7d6968  
    3030  * Base nodes now override `const Node * accept( Visitor & v ) const = 0` with, e.g. `const Stmt * accept( Visitor & v ) const override = 0`
    3131* `PassVisitor` is replaced with `ast::Pass`
     32  * Most one shot uses can use `ast::Pass::run` and `ast::Pass::read`.
     33
     34`WithConstTypeSubstitution`
     35* `env` => `typeSubs`
    3236
    3337## Structural Changes ##
    … …  
    146150  * allows `newObject` as just default settings
    147151
     152`FunctionDecl`
     153* `params` and `returns` added.
     154  * Contain the declarations of the parameters and return variables.
     155  * Types should match (even be shared with) the fields of `type`.
     156
    148157`NamedTypeDecl`
    149158* `parameters` => `params`
    … …  
    154163`AggregateDecl`
    155164* `parameters` => `params`
     165
     166`StructDecl`
     167* `makeInst` replaced by better constructor on `StructInstType`.
    156168
    157169`Expr`
    … …  
    245257* **TODO** move `kind`, `typeNames` into code generator
    246258
    247 `ReferenceToType`
     259`ReferenceToType` => `BaseInstType`
    248260* deleted `get_baseParameters()` from children
    249261  * replace with `aggr() ? aggr()->params : nullptr`
    … …  
    261273* `returnVals` => `returns`
    262274* `parameters` => `params`
     275  * Both now just point at types.
    263276* `bool isVarArgs;` => `enum ArgumentFlag { FixedArgs, VariableArgs }; ArgumentFlag isVarArgs;`
     277
     278`SueInstType`
     279* Template class, with specializations and using to implement some other types:
     280  * `StructInstType`, `UnionInstType` & `EnumInstType`
    264281
    265282`TypeInstType`

  • src/Concurrency/Keywords.cc

    r37b7d95 re7d6968  
    6666                        bool needs_main, AggregateDecl::Aggregate cast_target ) :
    6767                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ),
    68                   context_error( context_error ), vtable_name( getVTableName( exception_name ) ),
     68                  context_error( context_error ), exception_name( exception_name ),
     69                  vtable_name( getVTableName( exception_name ) ),
    6970                  needs_main( needs_main ), cast_target( cast_target ) {}
    7071
    … …  
    8990                const std::string getter_name;
    9091                const std::string context_error;
     92                const std::string exception_name;
    9193                const std::string vtable_name;
    9294                bool needs_main;
    … …  
    9597                StructDecl   * type_decl = nullptr;
    9698                FunctionDecl * dtor_decl = nullptr;
     99                StructDecl * except_decl = nullptr;
    97100                StructDecl * vtable_decl = nullptr;
    98101        };
    … …  
    376379                else if ( is_target(decl) ) {
    377380                        handle( decl );
     381                }
     382                else if ( !except_decl && exception_name == decl->name && decl->body ) {
     383                        except_decl = decl;
    378384                }
    379385                else if ( !vtable_decl && vtable_name == decl->name && decl->body ) {
    … …  
    398404                        assert( struct_type );
    399405
    400                         declsToAddAfter.push_back( Virtual::makeVtableInstance( vtable_decl, {
    401                                 new TypeExpr( struct_type->clone() ),
    402                         }, struct_type, nullptr ) );
     406                        std::list< Expression * > poly_args = { new TypeExpr( struct_type->clone() ) };
     407                        ObjectDecl * vtable_object = Virtual::makeVtableInstance(
     408                                vtable_decl->makeInst( poly_args ), struct_type, nullptr );
     409                        declsToAddAfter.push_back( vtable_object );
     410                        declsToAddAfter.push_back( Virtual::makeGetExceptionFunction(
     411                                vtable_object, except_decl->makeInst( std::move( poly_args ) )
     412                        ) );
    403413                }
    404414
    … …  
    434444        void ConcurrentSueKeyword::addVtableForward( StructDecl * decl ) {
    435445                if ( vtable_decl ) {
    436                         declsToAddBefore.push_back( Virtual::makeVtableForward( vtable_decl, {
     446                        std::list< Expression * > poly_args = {
    437447                                new TypeExpr( new StructInstType( noQualifiers, decl ) ),
    438                         } ) );
     448                        };
     449                        declsToAddBefore.push_back( Virtual::makeGetExceptionForward(
     450                                vtable_decl->makeInst( poly_args ),
     451                                except_decl->makeInst( poly_args )
     452                        ) );
     453                        declsToAddBefore.push_back( Virtual::makeVtableForward(
     454                                vtable_decl->makeInst( move( poly_args ) ) ) );
    439455                // Its only an error if we want a vtable and don't have one.
    440456                } else if ( ! vtable_name.empty() ) {

  • src/InitTweak/FixGlobalInit.cc

    r37b7d95 re7d6968  
    153153                        } // if
    154154                        if ( Statement * ctor = ctorInit->ctor ) {
     155                                addDataSectonAttribute( objDecl );
    155156                                initStatements.push_back( ctor );
    156157                                objDecl->init = nullptr;

  • src/InitTweak/FixInit.cc

    r37b7d95 re7d6968  
    802802                                if ( Statement * ctor = ctorInit->get_ctor() ) {
    803803                                        if ( objDecl->get_storageClasses().is_static ) {
     804
     805                                                // The ojbect needs to go in the data section, regardless of dtor complexity below.
     806                                                // The attribute works, and is meant to apply, both for leaving the static local alone,
     807                                                // and for hoisting it out as a static global.
     808                                                addDataSectonAttribute( objDecl );
     809
    804810                                                // originally wanted to take advantage of gcc nested functions, but
    805811                                                // we get memory errors with this approach. To remedy this, the static

  • src/InitTweak/InitTweak.cc

    r37b7d95 re7d6968  
    11031103                return isCopyFunction( decl, "?{}" );
    11041104        }
     1105
     1106        void addDataSectonAttribute( ObjectDecl * objDecl ) {
     1107                Type *strLitT = new PointerType( Type::Qualifiers( ),
     1108                        new BasicType( Type::Qualifiers( ), BasicType::Char ) );
     1109                std::list< Expression * > attr_params;
     1110                attr_params.push_back(
     1111                        new ConstantExpr( Constant( strLitT, "\".data#\"", std::nullopt ) ) );
     1112                objDecl->attributes.push_back(new Attribute("section", attr_params));
     1113        }
     1114
    11051115}

  • src/InitTweak/InitTweak.h

    r37b7d95 re7d6968  
    108108        bool isConstExpr( Initializer * init );
    109109
     110        /// Modifies objDecl to have:
     111        ///    __attribute__((section (".data#")))
     112        /// which makes gcc put the declared variable in the data section,
     113        /// which is helpful for global constants on newer gcc versions,
     114        /// so that CFA's generated initialization won't segfault when writing it via a const cast.
     115        /// The trailing # is an injected assembly comment, to suppress the "a" in
     116        ///    .section .data,"a"
     117        ///    .section .data#,"a"
     118        /// to avoid assembler warning "ignoring changed section attributes for .data"
     119        void addDataSectonAttribute( ObjectDecl * objDecl );
     120
    110121        class InitExpander_old {
    111122        public:

  • src/Parser/DeclarationNode.cc

    r37b7d95 re7d6968  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jun  9 20:26:55 2020
    13 // Update Count     : 1134
     12// Last Modified On : Thu Oct  8 08:03:38 2020
     13// Update Count     : 1135
    1414//
    1515
    … …  
    10161016                        if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
    10171017                                dwt->location = cur->location;
    1018                                 * out++ = dwt;
     1018                                *out++ = dwt;
    10191019                        } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
    10201020                                // e.g., int foo(struct S) {}
    … …  
    10221022                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
    10231023                                obj->location = cur->location;
    1024                                 * out++ = obj;
     1024                                *out++ = obj;
    10251025                                delete agg;
    10261026                        } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
    … …  
    10291029                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
    10301030                                obj->location = cur->location;
    1031                                 * out++ = obj;
     1031                                *out++ = obj;
    10321032                        } else if ( EnumDecl * agg = dynamic_cast< EnumDecl * >( decl ) ) {
    10331033                                // e.g., int foo(enum E) {}
    … …  
    10351035                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
    10361036                                obj->location = cur->location;
    1037                                 * out++ = obj;
     1037                                *out++ = obj;
    10381038                        } // if
    10391039                } catch( SemanticErrorException & e ) {

  • src/Parser/parser.yy

    r37b7d95 re7d6968  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Oct  6 18:24:18 2020
    13 // Update Count     : 4610
     12// Last Modified On : Fri Oct  9 18:09:09 2020
     13// Update Count     : 4614
    1414//
    1515
    … …  
    204204                        return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
    205205                } else {
    206                         SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); return nullptr;
     206                        SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed." ); return nullptr;
    207207                } // if
    208208        } else {
    209                 SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); return nullptr;
     209                SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed." ); return nullptr;
    210210        } // if
    211211} // forCtrl
    … …  
    24122412// Overloading: function, data, and operator identifiers may be overloaded.
    24132413//
    2414 // Type declarations: "type" is used to generate new types for declaring objects. Similarly, "dtype" is used for object
     2414// Type declarations: "otype" is used to generate new types for declaring objects. Similarly, "dtype" is used for object
    24152415//     and incomplete types, and "ftype" is used for function types. Type declarations with initializers provide
    24162416//     definitions of new types. Type declarations with storage class "extern" provide opaque types.
    … …  
    24412441        type_class identifier_or_type_name
    24422442                { typedefTable.addToScope( *$2, TYPEDEFname, "9" ); }
    2443           type_initializer_opt assertion_list_opt
     2443        type_initializer_opt assertion_list_opt
    24442444                { $$ = DeclarationNode::newTypeParam( $1, $2 )->addTypeInitializer( $4 )->addAssertions( $5 ); }
    24452445        | type_specifier identifier_parameter_declarator
    … …  
    24682468        assertion
    24692469        | assertion_list assertion
    2470                 { $$ = $1 ? $1->appendList( $2 ) : $2; }
     2470                { $$ = $1->appendList( $2 ); }
    24712471        ;
    24722472

  • src/SynTree/AggregateDecl.cc

    r37b7d95 re7d6968  
    2121#include "Common/utility.h"      // for printAll, cloneAll, deleteAll
    2222#include "Declaration.h"         // for AggregateDecl, TypeDecl, Declaration
     23#include "Expression.h"
    2324#include "Initializer.h"
    2425#include "LinkageSpec.h"         // for Spec, linkageName, Cforall
    … …  
    8889const char * StructDecl::typeString() const { return aggrString( kind ); }
    8990
     91StructInstType * StructDecl::makeInst( std::list< Expression * > const & new_parameters ) {
     92        std::list< Expression * > copy_parameters;
     93        cloneAll( new_parameters, copy_parameters );
     94        return makeInst( move( copy( copy_parameters ) ) );
     95}
     96
     97StructInstType * StructDecl::makeInst( std::list< Expression * > && new_parameters ) {
     98        assert( parameters.size() == new_parameters.size() );
     99        StructInstType * type = new StructInstType( noQualifiers, this );
     100        type->parameters = std::move( new_parameters );
     101        return type;
     102}
     103
    90104const char * UnionDecl::typeString() const { return aggrString( Union ); }
    91105

  • src/SynTree/Declaration.h

    r37b7d95 re7d6968  
    306306        bool is_thread   () { return kind == Thread   ; }
    307307
     308        // Make a type instance of this declaration.
     309        StructInstType * makeInst( std::list< Expression * > const & parameters );
     310        StructInstType * makeInst( std::list< Expression * > && parameters );
     311
    308312        virtual StructDecl * clone() const override { return new StructDecl( *this ); }
    309313        virtual void accept( Visitor & v ) override { v.visit( this ); }

  • src/SynTree/Expression.h

    r37b7d95 re7d6968  
    163163};
    164164
     165/// VariableExpr represents an expression that simply refers to the value of a named variable.
     166/// Does not take ownership of var.
     167class VariableExpr : public Expression {
     168  public:
     169        DeclarationWithType * var;
     170
     171        VariableExpr();
     172        VariableExpr( DeclarationWithType * var );
     173        VariableExpr( const VariableExpr & other );
     174        virtual ~VariableExpr();
     175
     176        bool get_lvalue() const final;
     177
     178        DeclarationWithType * get_var() const { return var; }
     179        void set_var( DeclarationWithType * newValue ) { var = newValue; }
     180
     181        static VariableExpr * functionPointer( FunctionDecl * decl );
     182
     183        virtual VariableExpr * clone() const override { return new VariableExpr( * this ); }
     184        virtual void accept( Visitor & v ) override { v.visit( this ); }
     185        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     186        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     187        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     188};
     189
    165190// The following classes are used to represent expression types that cannot be converted into
    166191// function-call format.
    … …  
    329354};
    330355
    331 /// VariableExpr represents an expression that simply refers to the value of a named variable.
    332 /// Does not take ownership of var.
    333 class VariableExpr : public Expression {
    334   public:
    335         DeclarationWithType * var;
    336 
    337         VariableExpr();
    338         VariableExpr( DeclarationWithType * var );
    339         VariableExpr( const VariableExpr & other );
    340         virtual ~VariableExpr();
    341 
    342         bool get_lvalue() const final;
    343 
    344         DeclarationWithType * get_var() const { return var; }
    345         void set_var( DeclarationWithType * newValue ) { var = newValue; }
    346 
    347         static VariableExpr * functionPointer( FunctionDecl * decl );
    348 
    349         virtual VariableExpr * clone() const override { return new VariableExpr( * this ); }
    350         virtual void accept( Visitor & v ) override { v.visit( this ); }
    351         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    352         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    353         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    354 };
    355 
    356356/// ConstantExpr represents an expression that simply refers to the value of a constant
    357357class ConstantExpr : public Expression {

  • src/SynTree/TypeDecl.cc

    r37b7d95 re7d6968  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 15:26:14 2019
    13 // Update Count     : 21
     12// Last Modified On : Thu Oct  8 18:18:55 2020
     13// Update Count     : 22
    1414//
    1515
    … …  
    2121#include "Type.h"            // for Type, Type::StorageClasses
    2222
    23 TypeDecl::TypeDecl( const std::string & name, Type::StorageClasses scs, Type * type, Kind kind, bool sized, Type * init ) : Parent( name, scs, type ), kind( kind ), sized( kind == Ttype || sized ), init( init ) {
     23TypeDecl::TypeDecl( const std::string & name, Type::StorageClasses scs, Type * type, Kind kind, bool sized, Type * init ) :
     24        Parent( name, scs, type ), kind( kind ), sized( kind == Ttype || sized ), init( init ) {
    2425}
    2526

  • src/Virtual/Tables.cc

    r37b7d95 re7d6968  
    1414//
    1515
     16#include <SynTree/Attribute.h>
    1617#include <SynTree/Declaration.h>
    1718#include <SynTree/Expression.h>
     19#include <SynTree/Statement.h>
    1820#include <SynTree/Type.h>
    1921
    … …  
    3840}
    3941
    40 // Fuse base polymorphic declaration and forall arguments into a new type.
    41 static StructInstType * vtableInstType(
    42                 StructDecl * polyDecl, std::list< Expression * > && parameters ) {
    43         assert( parameters.size() == polyDecl->parameters.size() );
    44         StructInstType * type = new StructInstType(
    45                         Type::Qualifiers( /* Type::Const */ ), polyDecl );
    46         type->parameters = std::move( parameters );
    47         return type;
    48 }
    49 
    5042static ObjectDecl * makeVtableDeclaration(
    5143                StructInstType * type, Initializer * init ) {
    … …  
    6658
    6759ObjectDecl * makeVtableForward( StructInstType * type ) {
     60        assert( type );
    6861        return makeVtableDeclaration( type, nullptr );
    6962}
    7063
    71 ObjectDecl * makeVtableForward(
    72                 StructDecl * polyDecl, std::list< Expression * > && parameters ) {
    73         return makeVtableForward( vtableInstType( polyDecl, std::move( parameters ) ) );
    74 }
    75 
    7664ObjectDecl * makeVtableInstance(
    77                 StructInstType * vtableType, Type * vobject_type, Initializer * init ) {
     65                StructInstType * vtableType, Type * objectType, Initializer * init ) {
     66        assert( vtableType );
     67        assert( objectType );
    7868        StructDecl * vtableStruct = vtableType->baseStruct;
    7969        // Build the initialization
    … …  
    9282                                                new SingleInit( new AddressExpr( new NameExpr( parentInstance ) ) ) );
    9383                        } else if ( std::string( "size" ) == field->name ) {
    94                                 inits.push_back( new SingleInit( new SizeofExpr( vobject_type->clone() ) ) );
     84                                inits.push_back( new SingleInit( new SizeofExpr( objectType->clone() ) ) );
    9585                        } else if ( std::string( "align" ) == field->name ) {
    96                                 inits.push_back( new SingleInit( new AlignofExpr( vobject_type->clone() ) ) );
     86                                inits.push_back( new SingleInit( new AlignofExpr( objectType->clone() ) ) );
    9787                        } else {
    9888                                inits.push_back( new SingleInit( new NameExpr( field->name ) ) );
    … …  
    10898}
    10999
    110 ObjectDecl * makeVtableInstance(
    111                 StructDecl * polyDecl, std::list< Expression * > && parameters,
    112                 Type * vobject, Initializer * init ) {
    113         return makeVtableInstance(
    114                 vtableInstType( polyDecl, std::move( parameters ) ), vobject, init );
     100namespace {
     101        std::string const functionName = "get_exception_vtable";
     102}
     103
     104FunctionDecl * makeGetExceptionForward(
     105                Type * vtableType, Type * exceptType ) {
     106        assert( vtableType );
     107        assert( exceptType );
     108        FunctionType * type = new FunctionType( noQualifiers, false );
     109        vtableType->tq.is_const = true;
     110        type->returnVals.push_back( new ObjectDecl(
     111                "_retvalue",
     112                noStorageClasses,
     113                LinkageSpec::Cforall,
     114                nullptr,
     115                new ReferenceType( noQualifiers, vtableType ),
     116                nullptr,
     117        { new Attribute("unused") }
     118        ) );
     119        type->parameters.push_back( new ObjectDecl(
     120                "__unused",
     121                noStorageClasses,
     122                LinkageSpec::Cforall,
     123                nullptr,
     124                new PointerType( noQualifiers, exceptType ),
     125                nullptr,
     126                { new Attribute("unused") }
     127        ) );
     128        return new FunctionDecl(
     129                functionName,
     130                noStorageClasses,
     131                LinkageSpec::Cforall,
     132                type,
     133                nullptr
     134        );
     135}
     136
     137FunctionDecl * makeGetExceptionFunction(
     138                ObjectDecl * vtableInstance, Type * exceptType ) {
     139        assert( vtableInstance );
     140        assert( exceptType );
     141        FunctionDecl * func = makeGetExceptionForward(
     142                vtableInstance->type->clone(), exceptType );
     143        func->statements = new CompoundStmt( {
     144                new ReturnStmt( new VariableExpr( vtableInstance ) ),
     145        } );
     146        return func;
    115147}
    116148

  • src/Virtual/Tables.h

    r37b7d95 re7d6968  
    2727bool isVTableInstanceName( std::string const & name );
    2828
    29 /// Converts exceptions into regular structures.
    30 //void ( std::list< Declaration * > & translationUnit );
    31 
    32 ObjectDecl * makeVtableForward( StructInstType * );
    33 ObjectDecl * makeVtableForward( StructDecl *, std::list< Expression * > && );
    34 /* Create a forward definition of a vtable of the given type.
    35  *
    36  * Instead of the virtual table type you may provide the declaration and all
    37  * the forall parameters.
     29ObjectDecl * makeVtableForward( StructInstType * vtableType );
     30/* Create a forward declaration of a vtable of the given type.
     31 * vtableType node is consumed.
    3832 */
    3933
    40 ObjectDecl * makeVtableInstance( StructInstType *, Type *, Initializer * );
    41 ObjectDecl * makeVtableInstance(
    42         StructDecl *, std::list< Expression * > &&, Type *, Initializer * );
     34ObjectDecl * makeVtableInstance( StructInstType * vtableType, Type * objectType,
     35        Initializer * init = nullptr );
    4336/* Create an initialized definition of a vtable.
    44  *
    45  * The parameters are the virtual table type (or the base declaration and the
    46  * forall parameters), the object type and optionally an initializer.
    47  *
    48  * Instead of the virtual table type you may provide the declaration and all
    49  * the forall parameters.
     37 * vtableType and init (if provided) nodes are consumed.
     38 */
     39
     40// Some special code for how exceptions interact with virtual tables.
     41FunctionDecl * makeGetExceptionForward( Type * vtableType, Type * exceptType );
     42/* Create a forward declaration of the exception virtual function
     43 * linking the vtableType to the exceptType. Both nodes are consumed.
     44 */
     45
     46FunctionDecl * makeGetExceptionFunction(
     47        ObjectDecl * vtableInstance, Type * exceptType );
     48/* Create the definition of the exception virtual function.
     49 * exceptType node is consumed.
    5050 */
    5151

  • src/main.cc

    r37b7d95 re7d6968  
    99// Author           : Peter Buhr and Rob Schluntz
    1010// Created On       : Fri May 15 23:12:02 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Tue May 19 12:03:00 2020
    13 // Update Count     : 634
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Thu Oct  8 18:17:46 2020
     13// Update Count     : 637
    1414//
    1515
    … …  
    458458
    459459
    460 static const char optstring[] = ":c:ghlLmNnpdP:S:twW:D:";
     460static const char optstring[] = ":c:ghlLmNnpdOAP:S:twW:D:";
    461461
    462462enum { PreludeDir = 128 };
    … …  
    485485
    486486static const char * description[] = {
    487         "diagnostic color: never, always, or auto.",          // -c
    488         "wait for gdb to attach",                             // -g
    489         "print help message",                                 // -h
    490         "generate libcfa.c",                                  // -l
    491         "generate line marks",                                // -L
    492         "do not replace main",                                // -m
    493         "do not generate line marks",                         // -N
    494         "do not read prelude",                                // -n
     487        "diagnostic color: never, always, or auto.",            // -c
     488        "wait for gdb to attach",                                                       // -g
     489        "print help message",                                                           // -h
     490        "generate libcfa.c",                                                            // -l
     491        "generate line marks",                                                          // -L
     492        "do not replace main",                                                          // -m
     493        "do not generate line marks",                                           // -N
     494        "do not read prelude",                                                          // -n
    495495        "generate prototypes for prelude functions",            // -p
    496         "don't print output that isn't deterministic",        // -d
    497         "Use the old-ast",                                    // -O
    498         "Use the new-ast",                                    // -A
    499         "print",                                              // -P
     496        "only print deterministic output",                  // -d
     497        "Use the old-ast",                                                                      // -O
     498        "Use the new-ast",                                                                      // -A
     499        "print",                                                                                        // -P
    500500        "<directory> prelude directory for debug/nodebug",      // no flag
    501501        "<option-list> enable profiling information:\n          counters,heap,time,all,none", // -S
    502         "building cfa standard lib",                          // -t
    503         "",                                                   // -w
    504         "",                                                   // -W
    505         "",                                                   // -D
     502        "building cfa standard lib",                                            // -t
     503        "",                                                                                                     // -w
     504        "",                                                                                                     // -W
     505        "",                                                                                                     // -D
    506506}; // description
    507507

  • tests/.expect/init1.txt

    r37b7d95 re7d6968  
    1 error: No reasonable alternatives for expression Untyped Init Expression
    2   Name: rx  InitAlternative: reference to signed int
    3 error: No reasonable alternatives for expression Untyped Init Expression
    4   Name: px  InitAlternative: pointer to signed int
    5 error: No reasonable alternatives for expression Untyped Init Expression
    6   Name: crx  InitAlternative: reference to float
    7 error: No reasonable alternatives for expression Untyped Init Expression
    8   Name: cpx  InitAlternative: pointer to float
    9 init1.cfa:94:1 error: No reasonable alternatives for expression Generated Cast of:
    10   Name: rx
    11 ... to:
    12   reference to signed int
    13 init1.cfa:97:1 error: No reasonable alternatives for expression Applying untyped:
    14   Name: ?{}
    15 ...to:
    16   Generated Cast of:
    17     Variable Expression: _retval_f_py: pointer to signed int
    18   ... to:
    19     reference to pointer to signed int
    20   Name: px
    21 
    22 init1.cfa:104:1 error: No reasonable alternatives for expression Generated Cast of:
    23   Name: crx
    24 ... to:
    25   reference to float
    26 init1.cfa:107:1 error: No reasonable alternatives for expression Applying untyped:
    27   Name: ?{}
    28 ...to:
    29   Generated Cast of:
    30     Variable Expression: _retval_f_py2: pointer to float
    31   ... to:
    32     reference to pointer to float
    33   Name: cpx
    34 
    35 init1.cfa:114:1 error: No reasonable alternatives for expression Generated Cast of:
    36   Name: s
    37 ... to:
    38   reference to instance of type T (not function type)
    39 init1.cfa:118:1 error: No reasonable alternatives for expression Applying untyped:
    40   Name: ?{}
    41 ...to:
    42   Generated Cast of:
    43     Variable Expression: _retval_anycvt: pointer to instance of type T (not function type)
    44   ... to:
    45     reference to pointer to instance of type T (not function type)
    46   Name: s
    47 
     1init1.cfa: In function '_X4mainFi___1':
     2init1.cfa:136:9: note: #pragma message: Compiled

  • tests/.expect/limits.txt

    r37b7d95 re7d6968  
    11limits.cfa: In function '_X4mainFi_iPPKc__1':
    2 limits.cfa:151:9: note: #pragma message: Compiled
     2limits.cfa:154:9: note: #pragma message: Compiled

  • tests/Makefile.am

    r37b7d95 re7d6968  
    1111## Created On       : Sun May 31 09:08:15 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Sun Sep 27 19:01:41 2020
    14 ## Update Count     : 84
     13## Last Modified On : Fri Oct  9 23:13:07 2020
     14## Update Count     : 86
    1515###############################################################################
    1616
    … …  
    141141
    142142SYNTAX_ONLY_CODE = expression typedefRedef variableDeclarator switch numericConstants identFuncDeclarator forall \
    143         limits nested-types stdincludes cast labelledExit array builtins/sync warnings/self-assignment
     143        init1 limits nested-types stdincludes cast labelledExit array builtins/sync warnings/self-assignment
    144144$(SYNTAX_ONLY_CODE): % : %.cfa $(CFACCBIN)
    145145        $(CFACOMPILE_SYNTAX)
    … …  
    149149# use custom target since they require a custom define *and* have a name that doesn't match the file
    150150alloc-ERROR : alloc.cfa $(CFACCBIN)
     151        $(CFACOMPILE_SYNTAX) -DERR1
     152        -cp $(test) $(abspath ${@})
     153
     154init1-ERROR : init1.cfa $(CFACCBIN)
    151155        $(CFACOMPILE_SYNTAX) -DERR1
    152156        -cp $(test) $(abspath ${@})

  • tests/alloc.cfa

    r37b7d95 re7d6968  
    1010// Created On       : Wed Feb  3 07:56:22 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Aug 14 16:59:59 2020
    13 // Update Count     : 430
     12// Last Modified On : Fri Oct  9 23:03:11 2020
     13// Update Count     : 431
    1414//
    1515
    … …  
    362362        ip = memset( stp, 10 );
    363363        ip = memcpy( &st1, &st );
    364 #endif
     364#endif // ERR1
    365365} // main
    366366

  • tests/complex.cfa

    r37b7d95 re7d6968  
    1414//
    1515
    16 #include <stdio.h>
    1716#include <complex.h>
    1817#ifdef __CFA__

  • tests/errors/.expect/completeType.x64.txt

    r37b7d95 re7d6968  
    132132?=?: pointer to function
    133133        ... with parameters
    134           reference to instance of type _109_0_T (not function type)
    135           instance of type _109_0_T (not function type)
     134          reference to instance of type _110_0_T (not function type)
     135          instance of type _110_0_T (not function type)
    136136        ... returning
    137           _retval__operator_assign: instance of type _109_0_T (not function type)
     137          _retval__operator_assign: instance of type _110_0_T (not function type)
    138138          ... with attributes:
    139139            Attribute with name: unused

  • tests/errors/.expect/completeType.x86.txt

    r37b7d95 re7d6968  
    132132?=?: pointer to function
    133133        ... with parameters
    134           reference to instance of type _108_0_T (not function type)
    135           instance of type _108_0_T (not function type)
     134          reference to instance of type _109_0_T (not function type)
     135          instance of type _109_0_T (not function type)
    136136        ... returning
    137           _retval__operator_assign: instance of type _108_0_T (not function type)
     137          _retval__operator_assign: instance of type _109_0_T (not function type)
    138138          ... with attributes:
    139139            Attribute with name: unused

  • tests/exceptions/cancel/coroutine.cfa

    r37b7d95 re7d6968  
    11// Try cancelling a coroutine.
    22
    3 #include <stdio.h>
    43#include <coroutine.hfa>
    54#include <exception.hfa>

  • tests/exceptions/conditional.cfa

    r37b7d95 re7d6968  
    55
    66#include <exception.hfa>
    7 #include <stdio.h>
    87
    98VTABLE_DECLARATION(num_error)(

  • tests/exceptions/defaults.cfa

    r37b7d95 re7d6968  
    5555
    5656void unhandled_test(void) {
    57         forall(dtype T | is_exception(T))
     57        forall(dtype T, dtype V | is_exception(T, V))
    5858        void defaultTerminationHandler(T &) {
    5959                throw (unhandled_exception){};

  • tests/exceptions/except-io.hfa

    r37b7d95 re7d6968  
    11// Common tools for the exception tests.
    2 
    3 #include <stdio.h>
    42
    53// Echo when a destructor is run and an area/block is left.

  • tests/exceptions/trash.cfa

    r37b7d95 re7d6968  
    22
    33#include <exception.hfa>
    4 #include <stdio.h>
    54
    65TRIVIAL_EXCEPTION(yin);

  • tests/global-monomorph.cfa

    r37b7d95 re7d6968  
    1 // Crea
    2 
    3 #include <stdlib.hfa>
    4 #include <stdio.h>
     1// Create monomorphic instances of polymorphic types at global scope.
    52
    63forall(dtype T)

  • tests/init1.cfa

    r37b7d95 re7d6968  
    99// Author           : Michael Brooks
    1010// Created On       : Thu Jul 16 22:00:00 2020
    11 // Last Modified By : Michael Brooks
    12 // Last Modified On : Thu Jul 16 22:00:00 2020
    13 // Update Count     : 1
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun Oct 11 10:26:50 2020
     13// Update Count     : 8
    1414//
    1515
    … …  
    4141    const float * cpx2 = cpx;
    4242
     43    // FIX ME: Code gen not producing correct cast.
     44#pragma GCC diagnostic push
     45#pragma GCC diagnostic ignored "-Wincompatible-pointer-types"
     46    int (* fp)( int ) = 0p;
     47    fp = 0p;
     48#pragma GCC diagnostic pop
     49
    4350    //
    4451    // unsound initializations
    4552    //
    4653
     54    #ifdef ERR1
    4755    // mismatched referenced type
    4856    int & ry = rx;
    … …  
    5260    float & ry2 = crx;
    5361    float * py2 = cpx;
     62    #endif // ERR1
    5463}
    5564
    … …  
    9099//
    91100
     101#ifdef ERR1
    92102int & f_ry() {
    93103    float & rx = *0p;
    … …  
    119129    return s;               // mismatched referenced type
    120130}
     131#endif // ERR1
     132
     133int main() {
     134    #pragma message( "Compiled" )                       // force non-empty .expect file
     135}

  • tests/limits.cfa

    r37b7d95 re7d6968  
    1313// Update Count     : 10
    1414//
     15
     16// Note: For testing the ability to load the constants defined in libcfa/src/limits.cfa,
     17// see discussion in test const-init.
    1518
    1619#include <limits.hfa>

  • tests/poly-d-cycle.cfa

    r37b7d95 re7d6968  
    11// Check that a cycle of polymorphic dtype structures can be instancated.
    2 
    3 #include <stdio.h>
    42
    53forall(dtype T)

  • tests/poly-o-cycle.cfa

    r37b7d95 re7d6968  
    11// Check that a cycle of polymorphic otype structures can be instancated.
    2 
    3 #include <stdio.h>
    42
    53forall(otype T)
Note: See TracChangeset for help on using the changeset viewer.