Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/libcfa/prelude.cf

    rf5ef08c r4040425  
    1 //                               -*- Mode: C -*-
    2 //
     1# 2 "prelude.cf"  // needed for error messages from this file
     2//                               -*- Mode: C -*-
     3//
    34// Copyright (C) Glen Ditchfield 1994, 1999
    4 //
     5// 
    56// prelude.cf -- Standard Cforall Preample for C99
    6 //
     7// 
    78// Author           : Glen Ditchfield
    89// Created On       : Sat Nov 29 07:23:41 2014
    910// Last Modified By : Peter A. Buhr
    10 // Last Modified On : Mon Jan  4 11:13:26 2016
    11 // Update Count     : 81
     11// Last Modified On : Wed Mar  2 18:03:41 2016
     12// Update Count     : 89
    1213//
    1314
    … …  
    6364long double _Complex    ?--( long double _Complex * ),          ?--( volatile long double _Complex * );
    6465
    65 forall( type T ) T *                     ?++(                T ** );
    66 forall( type T ) const T *               ?++( const          T ** );
    67 forall( type T ) volatile T *            ?++(       volatile T ** );
    68 forall( type T ) const volatile T *      ?++( const volatile T ** );
    69 forall( type T ) T *                     ?--(                T ** );
    70 forall( type T ) const T *               ?--( const          T ** );
    71 forall( type T ) volatile T *            ?--(       volatile T ** );
    72 forall( type T ) const volatile T *      ?--( const volatile T ** );
    73 
    74 forall( type T ) lvalue T                ?[?](                T *,          ptrdiff_t );
    75 forall( type T ) const lvalue T          ?[?]( const          T *,          ptrdiff_t );
    76 forall( type T ) volatile lvalue T       ?[?](       volatile T *,          ptrdiff_t );
    77 forall( type T ) const volatile lvalue T ?[?]( const volatile T *,          ptrdiff_t );
    78 forall( type T ) lvalue T                ?[?](          ptrdiff_t,                T * );
    79 forall( type T ) const lvalue T          ?[?](          ptrdiff_t, const          T * );
    80 forall( type T ) volatile lvalue T       ?[?](          ptrdiff_t,       volatile T * );
    81 forall( type T ) const volatile lvalue T ?[?](          ptrdiff_t, const volatile T * );
     66forall( otype T ) T *                    ?++(                T ** );
     67forall( otype T ) const T *              ?++( const          T ** );
     68forall( otype T ) volatile T *           ?++(       volatile T ** );
     69forall( otype T ) const volatile T *     ?++( const volatile T ** );
     70forall( otype T ) T *                    ?--(                T ** );
     71forall( otype T ) const T *              ?--( const          T ** );
     72forall( otype T ) volatile T *           ?--(       volatile T ** );
     73forall( otype T ) const volatile T *     ?--( const volatile T ** );
     74
     75forall( otype T ) lvalue T               ?[?](                T *,          ptrdiff_t );
     76forall( otype T ) const lvalue T         ?[?]( const          T *,          ptrdiff_t );
     77forall( otype T ) volatile lvalue T      ?[?](       volatile T *,          ptrdiff_t );
     78forall( otype T ) const volatile lvalue T ?[?]( const volatile T *,         ptrdiff_t );
     79forall( otype T ) lvalue T               ?[?](          ptrdiff_t,                T * );
     80forall( otype T ) const lvalue T         ?[?](          ptrdiff_t, const          T * );
     81forall( otype T ) volatile lvalue T      ?[?](          ptrdiff_t,       volatile T * );
     82forall( otype T ) const volatile lvalue T ?[?](         ptrdiff_t, const volatile T * );
    8283
    8384// ------------------------------------------------------------
    … …  
    101102long double _Complex    ++?( long double _Complex * ),          --?( long double _Complex * );
    102103
    103 forall( type T ) T *                     ++?(                T ** );
    104 forall( type T ) const T *               ++?( const          T ** );
    105 forall( type T ) volatile T *            ++?(       volatile T ** );
    106 forall( type T ) const volatile T *      ++?( const volatile T ** );
    107 forall( type T ) T *                     --?(                T ** );
    108 forall( type T ) const T *               --?( const          T ** );
    109 forall( type T ) volatile T *            --?(       volatile T ** );
    110 forall( type T ) const volatile T *      --?( const volatile T ** );
    111 
    112 forall( type T ) lvalue T                *?(                 T * );
    113 forall( type T ) const lvalue T          *?( const           T * );
    114 forall( type T ) volatile lvalue T       *?(       volatile  T * );
    115 forall( type T ) const volatile lvalue T *?( const volatile  T * );
     104forall( otype T ) T *                    ++?(                T ** );
     105forall( otype T ) const T *              ++?( const          T ** );
     106forall( otype T ) volatile T *           ++?(       volatile T ** );
     107forall( otype T ) const volatile T *     ++?( const volatile T ** );
     108forall( otype T ) T *                    --?(                T ** );
     109forall( otype T ) const T *              --?( const          T ** );
     110forall( otype T ) volatile T *           --?(       volatile T ** );
     111forall( otype T ) const volatile T *     --?( const volatile T ** );
     112
     113forall( otype T ) lvalue T               *?(                 T * );
     114forall( otype T ) const lvalue T                 *?( const           T * );
     115forall( otype T ) volatile lvalue T      *?(       volatile  T * );
     116forall( otype T ) const volatile lvalue T *?( const volatile  T * );
    116117forall( ftype FT ) lvalue FT             *?( FT * );
    117118
    118 _Bool                   +?( _Bool ),                    -?( _Bool ),                    ~?( _Bool );
    119 signed int              +?( signed int ),               -?( signed int ),               ~?( signed int );
    120 unsigned int            +?( unsigned int ),             -?( unsigned int ),             ~?( unsigned int );
    121 signed long int         +?( signed long int ),          -?( signed long int ),          ~?( signed long int );
    122 unsigned long int       +?( unsigned long int ),        -?( unsigned long int ),        ~?( unsigned long int );
    123 signed long long int    +?( signed long long int ),     -?( signed long long int ),     ~?( signed long long int );
    124 unsigned long long int  +?( unsigned long long int ),   -?( unsigned long long int ),   ~?( unsigned long long int );
     119_Bool                   +?( _Bool ),                    -?( _Bool ),                    ~?( _Bool );         
     120signed int              +?( signed int ),               -?( signed int ),               ~?( signed int );           
     121unsigned int            +?( unsigned int ),             -?( unsigned int ),             ~?( unsigned int );         
     122signed long int         +?( signed long int ),          -?( signed long int ),          ~?( signed long int );       
     123unsigned long int       +?( unsigned long int ),        -?( unsigned long int ),        ~?( unsigned long int );             
     124signed long long int    +?( signed long long int ),     -?( signed long long int ),     ~?( signed long long int );   
     125unsigned long long int  +?( unsigned long long int ),   -?( unsigned long long int ),   ~?( unsigned long long int ); 
    125126float                   +?( float ),                    -?( float );
    126127double                  +?( double ),                   -?( double );
    … …  
    183184long double _Complex    ?+?( long double _Complex, long double _Complex ),      ?-?( long double _Complex, long double _Complex );
    184185
    185 forall( type T ) T *                    ?+?(                T *,          ptrdiff_t );
    186 forall( type T ) T *                    ?+?(          ptrdiff_t,                T * );
    187 forall( type T ) const T *              ?+?( const          T *,          ptrdiff_t );
    188 forall( type T ) const T *              ?+?(          ptrdiff_t, const          T * );
    189 forall( type T ) volatile T *           ?+?(       volatile T *,          ptrdiff_t );
    190 forall( type T ) volatile T *           ?+?(          ptrdiff_t,       volatile T * );
    191 forall( type T ) const volatile T *     ?+?( const volatile T *,          ptrdiff_t );
    192 forall( type T ) const volatile T *     ?+?(          ptrdiff_t, const volatile T * );
    193 forall( type T ) T *                    ?-?(                T *,          ptrdiff_t );
    194 forall( type T ) const T *              ?-?( const          T *,          ptrdiff_t );
    195 forall( type T ) volatile T *           ?-?(       volatile T *,          ptrdiff_t );
    196 forall( type T ) const volatile T *     ?-?( const volatile T *,          ptrdiff_t );
    197 forall( type T ) ptrdiff_t              ?-?( const volatile T *, const volatile T * );
     186forall( otype T ) T *                   ?+?(                T *,          ptrdiff_t );
     187forall( otype T ) T *                   ?+?(          ptrdiff_t,                T * );
     188forall( otype T ) const T *             ?+?( const          T *,          ptrdiff_t );
     189forall( otype T ) const T *             ?+?(          ptrdiff_t, const          T * );
     190forall( otype T ) volatile T *          ?+?(       volatile T *,          ptrdiff_t );
     191forall( otype T ) volatile T *          ?+?(          ptrdiff_t,       volatile T * );
     192forall( otype T ) const volatile T *    ?+?( const volatile T *,          ptrdiff_t );
     193forall( otype T ) const volatile T *    ?+?(          ptrdiff_t, const volatile T * );
     194forall( otype T ) T *                   ?-?(                T *,          ptrdiff_t );
     195forall( otype T ) const T *             ?-?( const          T *,          ptrdiff_t );
     196forall( otype T ) volatile T *          ?-?(       volatile T *,          ptrdiff_t );
     197forall( otype T ) const volatile T *    ?-?( const volatile T *,          ptrdiff_t );
     198forall( otype T ) ptrdiff_t             ?-?( const volatile T *, const volatile T * );
    198199
    199200// ------------------------------------------------------------
    … …  
    431432forall( ftype FT ) FT *                 ?=?( FT * volatile *, forall( ftype FT2 ) FT2 * );
    432433
    433 forall( type T ) T *                    ?+=?(                T *          *, ptrdiff_t );
    434 forall( type T ) T *                    ?+=?(                T * volatile *, ptrdiff_t );
    435 forall( type T ) const T *              ?+=?( const          T *          *, ptrdiff_t );
    436 forall( type T ) const T *              ?+=?( const          T * volatile *, ptrdiff_t );
    437 forall( type T ) volatile T *           ?+=?(       volatile T *          *, ptrdiff_t );
    438 forall( type T ) volatile T *           ?+=?(       volatile T * volatile *, ptrdiff_t );
    439 forall( type T ) const volatile T *     ?+=?( const volatile T *          *, ptrdiff_t );
    440 forall( type T ) const volatile T *     ?+=?( const volatile T * volatile *, ptrdiff_t );
    441 forall( type T ) T *                    ?-=?(                T *          *, ptrdiff_t );
    442 forall( type T ) T *                    ?-=?(                T * volatile *, ptrdiff_t );
    443 forall( type T ) const T *              ?-=?( const          T *          *, ptrdiff_t );
    444 forall( type T ) const T *              ?-=?( const          T * volatile *, ptrdiff_t );
    445 forall( type T ) volatile T *           ?-=?(       volatile T *          *, ptrdiff_t );
    446 forall( type T ) volatile T *           ?-=?(       volatile T * volatile *, ptrdiff_t );
    447 forall( type T ) const volatile T *     ?-=?( const volatile T *          *, ptrdiff_t );
    448 forall( type T ) const volatile T *     ?-=?( const volatile T * volatile *, ptrdiff_t );
     434forall( otype T ) T *                   ?+=?(                T *          *, ptrdiff_t );
     435forall( otype T ) T *                   ?+=?(                T * volatile *, ptrdiff_t );
     436forall( otype T ) const T *             ?+=?( const          T *          *, ptrdiff_t );
     437forall( otype T ) const T *             ?+=?( const          T * volatile *, ptrdiff_t );
     438forall( otype T ) volatile T *          ?+=?(       volatile T *          *, ptrdiff_t );
     439forall( otype T ) volatile T *          ?+=?(       volatile T * volatile *, ptrdiff_t );
     440forall( otype T ) const volatile T *    ?+=?( const volatile T *          *, ptrdiff_t );
     441forall( otype T ) const volatile T *    ?+=?( const volatile T * volatile *, ptrdiff_t );
     442forall( otype T ) T *                   ?-=?(                T *          *, ptrdiff_t );
     443forall( otype T ) T *                   ?-=?(                T * volatile *, ptrdiff_t );
     444forall( otype T ) const T *             ?-=?( const          T *          *, ptrdiff_t );
     445forall( otype T ) const T *             ?-=?( const          T * volatile *, ptrdiff_t );
     446forall( otype T ) volatile T *          ?-=?(       volatile T *          *, ptrdiff_t );
     447forall( otype T ) volatile T *          ?-=?(       volatile T * volatile *, ptrdiff_t );
     448forall( otype T ) const volatile T *    ?-=?( const volatile T *          *, ptrdiff_t );
     449forall( otype T ) const volatile T *    ?-=?( const volatile T * volatile *, ptrdiff_t );
    449450
    450451_Bool                   ?=?( _Bool *, _Bool ),                                  ?=?( volatile _Bool *, _Bool );
    … …  
    626627                        ?+=?( long double _Complex *, long double _Complex ), ?+=?( volatile long double _Complex *, long double _Complex ),
    627628                        ?-=?( long double _Complex *, long double _Complex ), ?-=?( volatile long double _Complex *, long double _Complex );
    628 
    629 
    630 
    631 
    632 
    633 // ------------------------------------------------------------
    634 //
    635 // Section ??? Constructors and Destructors
    636 //
    637 // ------------------------------------------------------------
    638 
    639 // default ctor
    640 void    ?{}( _Bool * ),                         ?{}( volatile _Bool * );
    641 void    ?{}( char * ),  ?{}( volatile char * );
    642 void    ?{}( unsigned char * ), ?{}( volatile unsigned char * );
    643 void    ?{}( char signed * ),                   ?{}( volatile char signed * );
    644 void    ?{}( int short * ),                             ?{}( volatile int short * );
    645 void    ?{}( int short unsigned * ),    ?{}( volatile int short unsigned * );
    646 void    ?{}( signed int * ),                    ?{}( volatile signed int * );
    647 void    ?{}( unsigned int * ),                  ?{}( volatile unsigned int * );
    648 void    ?{}( signed long int * ),               ?{}( volatile signed long int * );
    649 void    ?{}( unsigned long int * ),             ?{}( volatile unsigned long int * );
    650 void    ?{}( signed long long int * ),          ?{}( volatile signed long long int * );
    651 void    ?{}( unsigned long long int * ),        ?{}( volatile unsigned long long int * );
    652 void    ?{}( float * ),                         ?{}( volatile float * );
    653 void    ?{}( double * ),                        ?{}( volatile double * );
    654 void    ?{}( long double * ),                   ?{}( volatile long double * );
    655 void    ?{}( float _Complex * ),                ?{}( volatile float _Complex * );
    656 void    ?{}( double _Complex * ),               ?{}( volatile double _Complex * );
    657 void    ?{}( long double _Complex * ),          ?{}( volatile long double _Complex * );
    658 
    659 // copy ctor
    660 void    ?{}( _Bool *, _Bool ),                                  ?{}( volatile _Bool *, _Bool );
    661 void    ?{}( char *, char ),    ?{}( volatile char *, char );
    662 void    ?{}( unsigned char *, unsigned char ),                  ?{}( volatile unsigned char *, unsigned char );
    663 void    ?{}( char signed *, char signed ),                      ?{}( volatile char signed *, char signed );
    664 void    ?{}( int short *, int short ),                          ?{}( volatile int short *, int short );
    665 void    ?{}( int short unsigned *, int short unsigned ),        ?{}( volatile int short unsigned *, int short unsigned );
    666 void    ?{}( signed int *, signed int),                         ?{}( volatile signed int *, signed int );
    667 void    ?{}( unsigned int *, unsigned int),                     ?{}( volatile unsigned int *, unsigned int );
    668 void    ?{}( signed long int *, signed long int),               ?{}( volatile signed long int *, signed long int );
    669 void    ?{}( unsigned long int *, unsigned long int),           ?{}( volatile unsigned long int *, unsigned long int );
    670 void    ?{}( signed long long int *, signed long long int),     ?{}( volatile signed long long int *, signed long long int );
    671 void    ?{}( unsigned long long int *, unsigned long long int), ?{}( volatile unsigned long long int *, unsigned long long int );
    672 void    ?{}( float *, float),                                   ?{}( volatile float *, float );
    673 void    ?{}( double *, double),                                 ?{}( volatile double *, double );
    674 void    ?{}( long double *, long double),                       ?{}( volatile long double *, long double );
    675 void    ?{}( float _Complex *, float _Complex),                 ?{}( volatile float _Complex *, float _Complex );
    676 void    ?{}( double _Complex *, double _Complex),               ?{}( volatile double _Complex *, double _Complex );
    677 void    ?{}( long double _Complex *, long double _Complex),     ?{}( volatile long double _Complex *, long double _Complex );
    678 
    679 // dtor
    680 void    ^?{}( _Bool * ),                        ^?{}( volatile _Bool * );
    681 void    ^?{}( char * ), ^?{}( volatile char * );
    682 void    ^?{}( char unsigned * ),                        ^?{}( volatile char unsigned * );
    683 void    ^?{}( char signed * ),                  ^?{}( volatile char signed * );
    684 void    ^?{}( int short * ),                            ^?{}( volatile int short * );
    685 void    ^?{}( int short unsigned * ),   ^?{}( volatile int short unsigned * );
    686 void    ^?{}( signed int * ),                   ^?{}( volatile signed int * );
    687 void    ^?{}( unsigned int * ),                 ^?{}( volatile unsigned int * );
    688 void    ^?{}( signed long int * ),              ^?{}( volatile signed long int * );
    689 void    ^?{}( unsigned long int * ),            ^?{}( volatile unsigned long int * );
    690 void    ^?{}( signed long long int * ),         ^?{}( volatile signed long long int * );
    691 void    ^?{}( unsigned long long int * ),       ^?{}( volatile unsigned long long int * );
    692 void    ^?{}( float * ),                        ^?{}( volatile float * );
    693 void    ^?{}( double * ),                       ^?{}( volatile double * );
    694 void    ^?{}( long double * ),                  ^?{}( volatile long double * );
    695 void    ^?{}( float _Complex * ),               ^?{}( volatile float _Complex * );
    696 void    ^?{}( double _Complex * ),              ^?{}( volatile double _Complex * );
    697 void    ^?{}( long double _Complex * ),         ^?{}( volatile long double _Complex * );
    698 
    699 // // default ctor
    700 // forall( dtype DT ) void       ?{}(                DT ** );
    701 // forall( dtype DT ) void       ?{}( const          DT ** );
    702 // forall( dtype DT ) void       ?{}(       volatile DT ** );
    703 // forall( dtype DT ) void       ?{}( const volatile DT ** );
    704 
    705 // // copy ctor
    706 // forall( dtype DT ) void       ?{}(                DT **, DT* );
    707 // forall( dtype DT ) void       ?{}( const          DT **, DT* );
    708 // forall( dtype DT ) void       ?{}(       volatile DT **, DT* );
    709 // forall( dtype DT ) void       ?{}( const volatile DT **, DT* );
    710 
    711 // // dtor
    712 // forall( dtype DT ) void      ^?{}(                DT ** );
    713 // forall( dtype DT ) void      ^?{}( const          DT ** );
    714 // forall( dtype DT ) void      ^?{}(       volatile DT ** );
    715 // forall( dtype DT ) void      ^?{}( const volatile DT ** );
    716 
    717 // copied from assignment section
    718 // copy constructors
    719 forall( ftype FT ) void ?{}( FT **, FT * );
    720 forall( ftype FT ) void ?{}( FT * volatile *, FT * );
    721 
    722 forall( dtype DT ) void ?{}(                 DT *          *,                   DT * );
    723 forall( dtype DT ) void ?{}(                 DT * volatile *,                   DT * );
    724 forall( dtype DT ) void ?{}( const           DT *          *,                   DT * );
    725 forall( dtype DT ) void ?{}( const           DT * volatile *,                   DT * );
    726 forall( dtype DT ) void ?{}( const           DT *          *, const             DT * );
    727 forall( dtype DT ) void ?{}( const           DT * volatile *, const             DT * );
    728 forall( dtype DT ) void ?{}(       volatile  DT *          *,                   DT * );
    729 forall( dtype DT ) void ?{}(       volatile  DT * volatile *,                   DT * );
    730 forall( dtype DT ) void ?{}(       volatile  DT *          *,       volatile    DT * );
    731 forall( dtype DT ) void ?{}(       volatile  DT * volatile *,       volatile    DT * );
    732 
    733 forall( dtype DT ) void ?{}( const volatile  DT *          *,                   DT * );
    734 forall( dtype DT ) void ?{}( const volatile  DT * volatile *,                   DT * );
    735 forall( dtype DT ) void ?{}( const volatile  DT *          *, const             DT * );
    736 forall( dtype DT ) void ?{}( const volatile  DT * volatile *, const             DT * );
    737 forall( dtype DT ) void ?{}( const volatile  DT *          *,       volatile    DT * );
    738 forall( dtype DT ) void ?{}( const volatile  DT * volatile *,       volatile    DT * );
    739 forall( dtype DT ) void ?{}( const volatile  DT *          *, const volatile    DT * );
    740 forall( dtype DT ) void ?{}( const volatile  DT * volatile *, const volatile    DT * );
    741 
    742 forall( dtype DT ) void ?{}(                 DT *          *,                   void * );
    743 forall( dtype DT ) void ?{}(                 DT * volatile *,                   void * );
    744 forall( dtype DT ) void ?{}( const           DT *          *,                   void * );
    745 forall( dtype DT ) void ?{}( const           DT * volatile *,                   void * );
    746 forall( dtype DT ) void ?{}( const           DT *          *, const             void * );
    747 forall( dtype DT ) void ?{}( const           DT * volatile *, const             void * );
    748 forall( dtype DT ) void ?{}(       volatile  DT *          *,                   void * );
    749 forall( dtype DT ) void ?{}(       volatile  DT * volatile *,                   void * );
    750 forall( dtype DT ) void ?{}(       volatile  DT *          *,       volatile    void * );
    751 forall( dtype DT ) void ?{}(       volatile  DT * volatile *,       volatile    void * );
    752 
    753 forall( dtype DT ) void ?{}( const volatile  DT *          *,                   void * );
    754 forall( dtype DT ) void ?{}( const volatile  DT * volatile *,                   void * );
    755 forall( dtype DT ) void ?{}( const volatile  DT *          *, const             void * );
    756 forall( dtype DT ) void ?{}( const volatile  DT * volatile *, const             void * );
    757 forall( dtype DT ) void ?{}( const volatile  DT *          *,       volatile    void * );
    758 forall( dtype DT ) void ?{}( const volatile  DT * volatile *,       volatile    void * );
    759 forall( dtype DT ) void ?{}( const volatile  DT *          *, const volatile    void * );
    760 forall( dtype DT ) void ?{}( const volatile  DT * volatile *, const volatile    void * );
    761 
    762 forall( dtype DT ) void ?{}(                 void *          *,                 DT * );
    763 forall( dtype DT ) void ?{}(                 void * volatile *,                 DT * );
    764 forall( dtype DT ) void ?{}( const           void *          *,                 DT * );
    765 forall( dtype DT ) void ?{}( const           void * volatile *,                 DT * );
    766 forall( dtype DT ) void ?{}( const           void *          *, const           DT * );
    767 forall( dtype DT ) void ?{}( const           void * volatile *, const           DT * );
    768 forall( dtype DT ) void ?{}(        volatile void *          *,                 DT * );
    769 forall( dtype DT ) void ?{}(        volatile void * volatile *,                 DT * );
    770 forall( dtype DT ) void ?{}(        volatile void *          *,       volatile  DT * );
    771 forall( dtype DT ) void ?{}(        volatile void * volatile *,       volatile  DT * );
    772 forall( dtype DT ) void ?{}( const volatile void *           *,                 DT * );
    773 forall( dtype DT ) void ?{}( const volatile void * volatile *,                  DT * );
    774 forall( dtype DT ) void ?{}( const volatile void *           *, const           DT * );
    775 forall( dtype DT ) void ?{}( const volatile void * volatile *, const            DT * );
    776 forall( dtype DT ) void ?{}( const volatile void *           *,       volatile  DT * );
    777 forall( dtype DT ) void ?{}( const volatile void * volatile *,        volatile  DT * );
    778 forall( dtype DT ) void ?{}( const volatile void *           *, const volatile  DT * );
    779 forall( dtype DT ) void ?{}( const volatile void * volatile *, const volatile   DT * );
    780 
    781 void    ?{}(                void *          *,                void * );
    782 void    ?{}(                void * volatile *,                void * );
    783 void    ?{}( const          void *          *,                void * );
    784 void    ?{}( const          void * volatile *,                void * );
    785 void    ?{}( const          void *          *, const          void * );
    786 void    ?{}( const          void * volatile *, const          void * );
    787 void    ?{}(       volatile void *          *,                void * );
    788 void    ?{}(       volatile void * volatile *,                void * );
    789 void    ?{}(       volatile void *          *,       volatile void * );
    790 void    ?{}(       volatile void * volatile *,       volatile void * );
    791 void    ?{}( const volatile void *          *,                void * );
    792 void    ?{}( const volatile void * volatile *,                void * );
    793 void    ?{}( const volatile void *          *, const          void * );
    794 void    ?{}( const volatile void * volatile *, const          void * );
    795 void    ?{}( const volatile void *          *,       volatile void * );
    796 void    ?{}( const volatile void * volatile *,       volatile void * );
    797 void    ?{}( const volatile void *          *, const volatile void * );
    798 void    ?{}( const volatile void * volatile *, const volatile void * );
    799 
    800 //forall( dtype DT ) void ?{}(              DT *          *, forall( dtype DT2 ) const DT2 * );
    801 //forall( dtype DT ) void ?{}(              DT * volatile *, forall( dtype DT2 ) const DT2 * );
    802 forall( dtype DT ) void ?{}( const          DT *          *, forall( dtype DT2 ) const DT2 * );
    803 forall( dtype DT ) void ?{}( const          DT * volatile *, forall( dtype DT2 ) const DT2 * );
    804 //forall( dtype DT ) void ?{}( volatile     DT *          *, forall( dtype DT2 ) const DT2 * );
    805 //forall( dtype DT ) void ?{}( volatile     DT * volatile *, forall( dtype DT2 ) const DT2 * );
    806 forall( dtype DT ) void ?{}( const volatile DT *          *, forall( dtype DT2 ) const DT2 * );
    807 forall( dtype DT ) void ?{}( const volatile DT * volatile *, forall( dtype DT2 ) const DT2 * );
    808 
    809 forall( ftype FT ) void ?{}( FT *          *, forall( ftype FT2 ) FT2 * );
    810 forall( ftype FT ) void ?{}( FT * volatile *, forall( ftype FT2 ) FT2 * );
    811 
    812 // default ctors
    813 forall( ftype FT ) void ?{}( FT *          * );
    814 forall( ftype FT ) void ?{}( FT * volatile * );
    815 
    816 forall( dtype DT ) void ?{}(                 DT *          *);
    817 forall( dtype DT ) void ?{}(                 DT * volatile *);
    818 forall( dtype DT ) void ?{}( const           DT *          *);
    819 forall( dtype DT ) void ?{}( const           DT * volatile *);
    820 forall( dtype DT ) void ?{}(       volatile  DT *          *);
    821 forall( dtype DT ) void ?{}(       volatile  DT * volatile *);
    822 forall( dtype DT ) void ?{}( const volatile  DT *          *);
    823 forall( dtype DT ) void ?{}( const volatile  DT * volatile *);
    824 
    825 void    ?{}(                void *          *);
    826 void    ?{}(                void * volatile *);
    827 void    ?{}( const          void *          *);
    828 void    ?{}( const          void * volatile *);
    829 void    ?{}(       volatile void *          *);
    830 void    ?{}(       volatile void * volatile *);
    831 void    ?{}( const volatile void *          *);
    832 void    ?{}( const volatile void * volatile *);
    833 
    834 // dtors
    835 forall( ftype FT ) void ^?{}( FT *         * );
    836 forall( ftype FT ) void ^?{}( FT * volatile * );
    837 
    838 forall( dtype DT ) void ^?{}(                DT *          *);
    839 forall( dtype DT ) void ^?{}(                DT * volatile *);
    840 forall( dtype DT ) void ^?{}( const          DT *          *);
    841 forall( dtype DT ) void ^?{}( const          DT * volatile *);
    842 forall( dtype DT ) void ^?{}(      volatile  DT *          *);
    843 forall( dtype DT ) void ^?{}(      volatile  DT * volatile *);
    844 forall( dtype DT ) void ^?{}( const volatile  DT *         *);
    845 forall( dtype DT ) void ^?{}( const volatile  DT * volatile *);
    846 
    847 void    ^?{}(               void *          *);
    848 void    ^?{}(               void * volatile *);
    849 void    ^?{}( const         void *          *);
    850 void    ^?{}( const         void * volatile *);
    851 void    ^?{}(      volatile void *          *);
    852 void    ^?{}(      volatile void * volatile *);
    853 void    ^?{}( const volatile void *         *);
    854 void    ^?{}( const volatile void * volatile *);
Note: See TracChangeset for help on using the changeset viewer.