Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/libcfa/prelude.cf

    r4040425 rf5ef08c  
    1 # 2 "prelude.cf"  // needed for error messages from this file
    2 //                               -*- Mode: C -*-
    3 //
     1//                               -*- Mode: C -*-
     2//
    43// Copyright (C) Glen Ditchfield 1994, 1999
    5 // 
     4//
    65// prelude.cf -- Standard Cforall Preample for C99
    7 // 
     6//
    87// Author           : Glen Ditchfield
    98// Created On       : Sat Nov 29 07:23:41 2014
    109// Last Modified By : Peter A. Buhr
    11 // Last Modified On : Wed Mar  2 18:03:41 2016
    12 // Update Count     : 89
     10// Last Modified On : Mon Jan  4 11:13:26 2016
     11// Update Count     : 81
    1312//
    1413
    … …  
    6463long double _Complex    ?--( long double _Complex * ),          ?--( volatile long double _Complex * );
    6564
    66 forall( otype T ) T *                    ?++(                T ** );
    67 forall( otype T ) const T *              ?++( const          T ** );
    68 forall( otype T ) volatile T *           ?++(       volatile T ** );
    69 forall( otype T ) const volatile T *     ?++( const volatile T ** );
    70 forall( otype T ) T *                    ?--(                T ** );
    71 forall( otype T ) const T *              ?--( const          T ** );
    72 forall( otype T ) volatile T *           ?--(       volatile T ** );
    73 forall( otype T ) const volatile T *     ?--( const volatile T ** );
    74 
    75 forall( otype T ) lvalue T               ?[?](                T *,          ptrdiff_t );
    76 forall( otype T ) const lvalue T         ?[?]( const          T *,          ptrdiff_t );
    77 forall( otype T ) volatile lvalue T      ?[?](       volatile T *,          ptrdiff_t );
    78 forall( otype T ) const volatile lvalue T ?[?]( const volatile T *,         ptrdiff_t );
    79 forall( otype T ) lvalue T               ?[?](          ptrdiff_t,                T * );
    80 forall( otype T ) const lvalue T         ?[?](          ptrdiff_t, const          T * );
    81 forall( otype T ) volatile lvalue T      ?[?](          ptrdiff_t,       volatile T * );
    82 forall( otype T ) const volatile lvalue T ?[?](         ptrdiff_t, const volatile T * );
     65forall( type T ) T *                     ?++(                T ** );
     66forall( type T ) const T *               ?++( const          T ** );
     67forall( type T ) volatile T *            ?++(       volatile T ** );
     68forall( type T ) const volatile T *      ?++( const volatile T ** );
     69forall( type T ) T *                     ?--(                T ** );
     70forall( type T ) const T *               ?--( const          T ** );
     71forall( type T ) volatile T *            ?--(       volatile T ** );
     72forall( type T ) const volatile T *      ?--( const volatile T ** );
     73
     74forall( type T ) lvalue T                ?[?](                T *,          ptrdiff_t );
     75forall( type T ) const lvalue T          ?[?]( const          T *,          ptrdiff_t );
     76forall( type T ) volatile lvalue T       ?[?](       volatile T *,          ptrdiff_t );
     77forall( type T ) const volatile lvalue T ?[?]( const volatile T *,          ptrdiff_t );
     78forall( type T ) lvalue T                ?[?](          ptrdiff_t,                T * );
     79forall( type T ) const lvalue T          ?[?](          ptrdiff_t, const          T * );
     80forall( type T ) volatile lvalue T       ?[?](          ptrdiff_t,       volatile T * );
     81forall( type T ) const volatile lvalue T ?[?](          ptrdiff_t, const volatile T * );
    8382
    8483// ------------------------------------------------------------
    … …  
    102101long double _Complex    ++?( long double _Complex * ),          --?( long double _Complex * );
    103102
    104 forall( otype T ) T *                    ++?(                T ** );
    105 forall( otype T ) const T *              ++?( const          T ** );
    106 forall( otype T ) volatile T *           ++?(       volatile T ** );
    107 forall( otype T ) const volatile T *     ++?( const volatile T ** );
    108 forall( otype T ) T *                    --?(                T ** );
    109 forall( otype T ) const T *              --?( const          T ** );
    110 forall( otype T ) volatile T *           --?(       volatile T ** );
    111 forall( otype T ) const volatile T *     --?( const volatile T ** );
    112 
    113 forall( otype T ) lvalue T               *?(                 T * );
    114 forall( otype T ) const lvalue T                 *?( const           T * );
    115 forall( otype T ) volatile lvalue T      *?(       volatile  T * );
    116 forall( otype T ) const volatile lvalue T *?( const volatile  T * );
     103forall( type T ) T *                     ++?(                T ** );
     104forall( type T ) const T *               ++?( const          T ** );
     105forall( type T ) volatile T *            ++?(       volatile T ** );
     106forall( type T ) const volatile T *      ++?( const volatile T ** );
     107forall( type T ) T *                     --?(                T ** );
     108forall( type T ) const T *               --?( const          T ** );
     109forall( type T ) volatile T *            --?(       volatile T ** );
     110forall( type T ) const volatile T *      --?( const volatile T ** );
     111
     112forall( type T ) lvalue T                *?(                 T * );
     113forall( type T ) const lvalue T          *?( const           T * );
     114forall( type T ) volatile lvalue T       *?(       volatile  T * );
     115forall( type T ) const volatile lvalue T *?( const volatile  T * );
    117116forall( ftype FT ) lvalue FT             *?( FT * );
    118117
    119 _Bool                   +?( _Bool ),                    -?( _Bool ),                    ~?( _Bool );         
    120 signed int              +?( signed int ),               -?( signed int ),               ~?( signed int );           
    121 unsigned int            +?( unsigned int ),             -?( unsigned int ),             ~?( unsigned int );         
    122 signed long int         +?( signed long int ),          -?( signed long int ),          ~?( signed long int );       
    123 unsigned long int       +?( unsigned long int ),        -?( unsigned long int ),        ~?( unsigned long int );             
    124 signed long long int    +?( signed long long int ),     -?( signed long long int ),     ~?( signed long long int );   
    125 unsigned long long int  +?( unsigned long long int ),   -?( unsigned long long int ),   ~?( unsigned long long int ); 
     118_Bool                   +?( _Bool ),                    -?( _Bool ),                    ~?( _Bool );
     119signed int              +?( signed int ),               -?( signed int ),               ~?( signed int );
     120unsigned int            +?( unsigned int ),             -?( unsigned int ),             ~?( unsigned int );
     121signed long int         +?( signed long int ),          -?( signed long int ),          ~?( signed long int );
     122unsigned long int       +?( unsigned long int ),        -?( unsigned long int ),        ~?( unsigned long int );
     123signed long long int    +?( signed long long int ),     -?( signed long long int ),     ~?( signed long long int );
     124unsigned long long int  +?( unsigned long long int ),   -?( unsigned long long int ),   ~?( unsigned long long int );
    126125float                   +?( float ),                    -?( float );
    127126double                  +?( double ),                   -?( double );
    … …  
    184183long double _Complex    ?+?( long double _Complex, long double _Complex ),      ?-?( long double _Complex, long double _Complex );
    185184
    186 forall( otype T ) T *                   ?+?(                T *,          ptrdiff_t );
    187 forall( otype T ) T *                   ?+?(          ptrdiff_t,                T * );
    188 forall( otype T ) const T *             ?+?( const          T *,          ptrdiff_t );
    189 forall( otype T ) const T *             ?+?(          ptrdiff_t, const          T * );
    190 forall( otype T ) volatile T *          ?+?(       volatile T *,          ptrdiff_t );
    191 forall( otype T ) volatile T *          ?+?(          ptrdiff_t,       volatile T * );
    192 forall( otype T ) const volatile T *    ?+?( const volatile T *,          ptrdiff_t );
    193 forall( otype T ) const volatile T *    ?+?(          ptrdiff_t, const volatile T * );
    194 forall( otype T ) T *                   ?-?(                T *,          ptrdiff_t );
    195 forall( otype T ) const T *             ?-?( const          T *,          ptrdiff_t );
    196 forall( otype T ) volatile T *          ?-?(       volatile T *,          ptrdiff_t );
    197 forall( otype T ) const volatile T *    ?-?( const volatile T *,          ptrdiff_t );
    198 forall( otype T ) ptrdiff_t             ?-?( const volatile T *, const volatile T * );
     185forall( type T ) T *                    ?+?(                T *,          ptrdiff_t );
     186forall( type T ) T *                    ?+?(          ptrdiff_t,                T * );
     187forall( type T ) const T *              ?+?( const          T *,          ptrdiff_t );
     188forall( type T ) const T *              ?+?(          ptrdiff_t, const          T * );
     189forall( type T ) volatile T *           ?+?(       volatile T *,          ptrdiff_t );
     190forall( type T ) volatile T *           ?+?(          ptrdiff_t,       volatile T * );
     191forall( type T ) const volatile T *     ?+?( const volatile T *,          ptrdiff_t );
     192forall( type T ) const volatile T *     ?+?(          ptrdiff_t, const volatile T * );
     193forall( type T ) T *                    ?-?(                T *,          ptrdiff_t );
     194forall( type T ) const T *              ?-?( const          T *,          ptrdiff_t );
     195forall( type T ) volatile T *           ?-?(       volatile T *,          ptrdiff_t );
     196forall( type T ) const volatile T *     ?-?( const volatile T *,          ptrdiff_t );
     197forall( type T ) ptrdiff_t              ?-?( const volatile T *, const volatile T * );
    199198
    200199// ------------------------------------------------------------
    … …  
    432431forall( ftype FT ) FT *                 ?=?( FT * volatile *, forall( ftype FT2 ) FT2 * );
    433432
    434 forall( otype T ) T *                   ?+=?(                T *          *, ptrdiff_t );
    435 forall( otype T ) T *                   ?+=?(                T * volatile *, ptrdiff_t );
    436 forall( otype T ) const T *             ?+=?( const          T *          *, ptrdiff_t );
    437 forall( otype T ) const T *             ?+=?( const          T * volatile *, ptrdiff_t );
    438 forall( otype T ) volatile T *          ?+=?(       volatile T *          *, ptrdiff_t );
    439 forall( otype T ) volatile T *          ?+=?(       volatile T * volatile *, ptrdiff_t );
    440 forall( otype T ) const volatile T *    ?+=?( const volatile T *          *, ptrdiff_t );
    441 forall( otype T ) const volatile T *    ?+=?( const volatile T * volatile *, ptrdiff_t );
    442 forall( otype T ) T *                   ?-=?(                T *          *, ptrdiff_t );
    443 forall( otype T ) T *                   ?-=?(                T * volatile *, ptrdiff_t );
    444 forall( otype T ) const T *             ?-=?( const          T *          *, ptrdiff_t );
    445 forall( otype T ) const T *             ?-=?( const          T * volatile *, ptrdiff_t );
    446 forall( otype T ) volatile T *          ?-=?(       volatile T *          *, ptrdiff_t );
    447 forall( otype T ) volatile T *          ?-=?(       volatile T * volatile *, ptrdiff_t );
    448 forall( otype T ) const volatile T *    ?-=?( const volatile T *          *, ptrdiff_t );
    449 forall( otype T ) const volatile T *    ?-=?( const volatile T * volatile *, ptrdiff_t );
     433forall( type T ) T *                    ?+=?(                T *          *, ptrdiff_t );
     434forall( type T ) T *                    ?+=?(                T * volatile *, ptrdiff_t );
     435forall( type T ) const T *              ?+=?( const          T *          *, ptrdiff_t );
     436forall( type T ) const T *              ?+=?( const          T * volatile *, ptrdiff_t );
     437forall( type T ) volatile T *           ?+=?(       volatile T *          *, ptrdiff_t );
     438forall( type T ) volatile T *           ?+=?(       volatile T * volatile *, ptrdiff_t );
     439forall( type T ) const volatile T *     ?+=?( const volatile T *          *, ptrdiff_t );
     440forall( type T ) const volatile T *     ?+=?( const volatile T * volatile *, ptrdiff_t );
     441forall( type T ) T *                    ?-=?(                T *          *, ptrdiff_t );
     442forall( type T ) T *                    ?-=?(                T * volatile *, ptrdiff_t );
     443forall( type T ) const T *              ?-=?( const          T *          *, ptrdiff_t );
     444forall( type T ) const T *              ?-=?( const          T * volatile *, ptrdiff_t );
     445forall( type T ) volatile T *           ?-=?(       volatile T *          *, ptrdiff_t );
     446forall( type T ) volatile T *           ?-=?(       volatile T * volatile *, ptrdiff_t );
     447forall( type T ) const volatile T *     ?-=?( const volatile T *          *, ptrdiff_t );
     448forall( type T ) const volatile T *     ?-=?( const volatile T * volatile *, ptrdiff_t );
    450449
    451450_Bool                   ?=?( _Bool *, _Bool ),                                  ?=?( volatile _Bool *, _Bool );
    … …  
    627626                        ?+=?( long double _Complex *, long double _Complex ), ?+=?( volatile long double _Complex *, long double _Complex ),
    628627                        ?-=?( 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
     640void    ?{}( _Bool * ),                         ?{}( volatile _Bool * );
     641void    ?{}( char * ),  ?{}( volatile char * );
     642void    ?{}( unsigned char * ), ?{}( volatile unsigned char * );
     643void    ?{}( char signed * ),                   ?{}( volatile char signed * );
     644void    ?{}( int short * ),                             ?{}( volatile int short * );
     645void    ?{}( int short unsigned * ),    ?{}( volatile int short unsigned * );
     646void    ?{}( signed int * ),                    ?{}( volatile signed int * );
     647void    ?{}( unsigned int * ),                  ?{}( volatile unsigned int * );
     648void    ?{}( signed long int * ),               ?{}( volatile signed long int * );
     649void    ?{}( unsigned long int * ),             ?{}( volatile unsigned long int * );
     650void    ?{}( signed long long int * ),          ?{}( volatile signed long long int * );
     651void    ?{}( unsigned long long int * ),        ?{}( volatile unsigned long long int * );
     652void    ?{}( float * ),                         ?{}( volatile float * );
     653void    ?{}( double * ),                        ?{}( volatile double * );
     654void    ?{}( long double * ),                   ?{}( volatile long double * );
     655void    ?{}( float _Complex * ),                ?{}( volatile float _Complex * );
     656void    ?{}( double _Complex * ),               ?{}( volatile double _Complex * );
     657void    ?{}( long double _Complex * ),          ?{}( volatile long double _Complex * );
     658
     659// copy ctor
     660void    ?{}( _Bool *, _Bool ),                                  ?{}( volatile _Bool *, _Bool );
     661void    ?{}( char *, char ),    ?{}( volatile char *, char );
     662void    ?{}( unsigned char *, unsigned char ),                  ?{}( volatile unsigned char *, unsigned char );
     663void    ?{}( char signed *, char signed ),                      ?{}( volatile char signed *, char signed );
     664void    ?{}( int short *, int short ),                          ?{}( volatile int short *, int short );
     665void    ?{}( int short unsigned *, int short unsigned ),        ?{}( volatile int short unsigned *, int short unsigned );
     666void    ?{}( signed int *, signed int),                         ?{}( volatile signed int *, signed int );
     667void    ?{}( unsigned int *, unsigned int),                     ?{}( volatile unsigned int *, unsigned int );
     668void    ?{}( signed long int *, signed long int),               ?{}( volatile signed long int *, signed long int );
     669void    ?{}( unsigned long int *, unsigned long int),           ?{}( volatile unsigned long int *, unsigned long int );
     670void    ?{}( signed long long int *, signed long long int),     ?{}( volatile signed long long int *, signed long long int );
     671void    ?{}( unsigned long long int *, unsigned long long int), ?{}( volatile unsigned long long int *, unsigned long long int );
     672void    ?{}( float *, float),                                   ?{}( volatile float *, float );
     673void    ?{}( double *, double),                                 ?{}( volatile double *, double );
     674void    ?{}( long double *, long double),                       ?{}( volatile long double *, long double );
     675void    ?{}( float _Complex *, float _Complex),                 ?{}( volatile float _Complex *, float _Complex );
     676void    ?{}( double _Complex *, double _Complex),               ?{}( volatile double _Complex *, double _Complex );
     677void    ?{}( long double _Complex *, long double _Complex),     ?{}( volatile long double _Complex *, long double _Complex );
     678
     679// dtor
     680void    ^?{}( _Bool * ),                        ^?{}( volatile _Bool * );
     681void    ^?{}( char * ), ^?{}( volatile char * );
     682void    ^?{}( char unsigned * ),                        ^?{}( volatile char unsigned * );
     683void    ^?{}( char signed * ),                  ^?{}( volatile char signed * );
     684void    ^?{}( int short * ),                            ^?{}( volatile int short * );
     685void    ^?{}( int short unsigned * ),   ^?{}( volatile int short unsigned * );
     686void    ^?{}( signed int * ),                   ^?{}( volatile signed int * );
     687void    ^?{}( unsigned int * ),                 ^?{}( volatile unsigned int * );
     688void    ^?{}( signed long int * ),              ^?{}( volatile signed long int * );
     689void    ^?{}( unsigned long int * ),            ^?{}( volatile unsigned long int * );
     690void    ^?{}( signed long long int * ),         ^?{}( volatile signed long long int * );
     691void    ^?{}( unsigned long long int * ),       ^?{}( volatile unsigned long long int * );
     692void    ^?{}( float * ),                        ^?{}( volatile float * );
     693void    ^?{}( double * ),                       ^?{}( volatile double * );
     694void    ^?{}( long double * ),                  ^?{}( volatile long double * );
     695void    ^?{}( float _Complex * ),               ^?{}( volatile float _Complex * );
     696void    ^?{}( double _Complex * ),              ^?{}( volatile double _Complex * );
     697void    ^?{}( 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
     719forall( ftype FT ) void ?{}( FT **, FT * );
     720forall( ftype FT ) void ?{}( FT * volatile *, FT * );
     721
     722forall( dtype DT ) void ?{}(                 DT *          *,                   DT * );
     723forall( dtype DT ) void ?{}(                 DT * volatile *,                   DT * );
     724forall( dtype DT ) void ?{}( const           DT *          *,                   DT * );
     725forall( dtype DT ) void ?{}( const           DT * volatile *,                   DT * );
     726forall( dtype DT ) void ?{}( const           DT *          *, const             DT * );
     727forall( dtype DT ) void ?{}( const           DT * volatile *, const             DT * );
     728forall( dtype DT ) void ?{}(       volatile  DT *          *,                   DT * );
     729forall( dtype DT ) void ?{}(       volatile  DT * volatile *,                   DT * );
     730forall( dtype DT ) void ?{}(       volatile  DT *          *,       volatile    DT * );
     731forall( dtype DT ) void ?{}(       volatile  DT * volatile *,       volatile    DT * );
     732
     733forall( dtype DT ) void ?{}( const volatile  DT *          *,                   DT * );
     734forall( dtype DT ) void ?{}( const volatile  DT * volatile *,                   DT * );
     735forall( dtype DT ) void ?{}( const volatile  DT *          *, const             DT * );
     736forall( dtype DT ) void ?{}( const volatile  DT * volatile *, const             DT * );
     737forall( dtype DT ) void ?{}( const volatile  DT *          *,       volatile    DT * );
     738forall( dtype DT ) void ?{}( const volatile  DT * volatile *,       volatile    DT * );
     739forall( dtype DT ) void ?{}( const volatile  DT *          *, const volatile    DT * );
     740forall( dtype DT ) void ?{}( const volatile  DT * volatile *, const volatile    DT * );
     741
     742forall( dtype DT ) void ?{}(                 DT *          *,                   void * );
     743forall( dtype DT ) void ?{}(                 DT * volatile *,                   void * );
     744forall( dtype DT ) void ?{}( const           DT *          *,                   void * );
     745forall( dtype DT ) void ?{}( const           DT * volatile *,                   void * );
     746forall( dtype DT ) void ?{}( const           DT *          *, const             void * );
     747forall( dtype DT ) void ?{}( const           DT * volatile *, const             void * );
     748forall( dtype DT ) void ?{}(       volatile  DT *          *,                   void * );
     749forall( dtype DT ) void ?{}(       volatile  DT * volatile *,                   void * );
     750forall( dtype DT ) void ?{}(       volatile  DT *          *,       volatile    void * );
     751forall( dtype DT ) void ?{}(       volatile  DT * volatile *,       volatile    void * );
     752
     753forall( dtype DT ) void ?{}( const volatile  DT *          *,                   void * );
     754forall( dtype DT ) void ?{}( const volatile  DT * volatile *,                   void * );
     755forall( dtype DT ) void ?{}( const volatile  DT *          *, const             void * );
     756forall( dtype DT ) void ?{}( const volatile  DT * volatile *, const             void * );
     757forall( dtype DT ) void ?{}( const volatile  DT *          *,       volatile    void * );
     758forall( dtype DT ) void ?{}( const volatile  DT * volatile *,       volatile    void * );
     759forall( dtype DT ) void ?{}( const volatile  DT *          *, const volatile    void * );
     760forall( dtype DT ) void ?{}( const volatile  DT * volatile *, const volatile    void * );
     761
     762forall( dtype DT ) void ?{}(                 void *          *,                 DT * );
     763forall( dtype DT ) void ?{}(                 void * volatile *,                 DT * );
     764forall( dtype DT ) void ?{}( const           void *          *,                 DT * );
     765forall( dtype DT ) void ?{}( const           void * volatile *,                 DT * );
     766forall( dtype DT ) void ?{}( const           void *          *, const           DT * );
     767forall( dtype DT ) void ?{}( const           void * volatile *, const           DT * );
     768forall( dtype DT ) void ?{}(        volatile void *          *,                 DT * );
     769forall( dtype DT ) void ?{}(        volatile void * volatile *,                 DT * );
     770forall( dtype DT ) void ?{}(        volatile void *          *,       volatile  DT * );
     771forall( dtype DT ) void ?{}(        volatile void * volatile *,       volatile  DT * );
     772forall( dtype DT ) void ?{}( const volatile void *           *,                 DT * );
     773forall( dtype DT ) void ?{}( const volatile void * volatile *,                  DT * );
     774forall( dtype DT ) void ?{}( const volatile void *           *, const           DT * );
     775forall( dtype DT ) void ?{}( const volatile void * volatile *, const            DT * );
     776forall( dtype DT ) void ?{}( const volatile void *           *,       volatile  DT * );
     777forall( dtype DT ) void ?{}( const volatile void * volatile *,        volatile  DT * );
     778forall( dtype DT ) void ?{}( const volatile void *           *, const volatile  DT * );
     779forall( dtype DT ) void ?{}( const volatile void * volatile *, const volatile   DT * );
     780
     781void    ?{}(                void *          *,                void * );
     782void    ?{}(                void * volatile *,                void * );
     783void    ?{}( const          void *          *,                void * );
     784void    ?{}( const          void * volatile *,                void * );
     785void    ?{}( const          void *          *, const          void * );
     786void    ?{}( const          void * volatile *, const          void * );
     787void    ?{}(       volatile void *          *,                void * );
     788void    ?{}(       volatile void * volatile *,                void * );
     789void    ?{}(       volatile void *          *,       volatile void * );
     790void    ?{}(       volatile void * volatile *,       volatile void * );
     791void    ?{}( const volatile void *          *,                void * );
     792void    ?{}( const volatile void * volatile *,                void * );
     793void    ?{}( const volatile void *          *, const          void * );
     794void    ?{}( const volatile void * volatile *, const          void * );
     795void    ?{}( const volatile void *          *,       volatile void * );
     796void    ?{}( const volatile void * volatile *,       volatile void * );
     797void    ?{}( const volatile void *          *, const volatile void * );
     798void    ?{}( 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 * );
     802forall( dtype DT ) void ?{}( const          DT *          *, forall( dtype DT2 ) const DT2 * );
     803forall( 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 * );
     806forall( dtype DT ) void ?{}( const volatile DT *          *, forall( dtype DT2 ) const DT2 * );
     807forall( dtype DT ) void ?{}( const volatile DT * volatile *, forall( dtype DT2 ) const DT2 * );
     808
     809forall( ftype FT ) void ?{}( FT *          *, forall( ftype FT2 ) FT2 * );
     810forall( ftype FT ) void ?{}( FT * volatile *, forall( ftype FT2 ) FT2 * );
     811
     812// default ctors
     813forall( ftype FT ) void ?{}( FT *          * );
     814forall( ftype FT ) void ?{}( FT * volatile * );
     815
     816forall( dtype DT ) void ?{}(                 DT *          *);
     817forall( dtype DT ) void ?{}(                 DT * volatile *);
     818forall( dtype DT ) void ?{}( const           DT *          *);
     819forall( dtype DT ) void ?{}( const           DT * volatile *);
     820forall( dtype DT ) void ?{}(       volatile  DT *          *);
     821forall( dtype DT ) void ?{}(       volatile  DT * volatile *);
     822forall( dtype DT ) void ?{}( const volatile  DT *          *);
     823forall( dtype DT ) void ?{}( const volatile  DT * volatile *);
     824
     825void    ?{}(                void *          *);
     826void    ?{}(                void * volatile *);
     827void    ?{}( const          void *          *);
     828void    ?{}( const          void * volatile *);
     829void    ?{}(       volatile void *          *);
     830void    ?{}(       volatile void * volatile *);
     831void    ?{}( const volatile void *          *);
     832void    ?{}( const volatile void * volatile *);
     833
     834// dtors
     835forall( ftype FT ) void ^?{}( FT *         * );
     836forall( ftype FT ) void ^?{}( FT * volatile * );
     837
     838forall( dtype DT ) void ^?{}(                DT *          *);
     839forall( dtype DT ) void ^?{}(                DT * volatile *);
     840forall( dtype DT ) void ^?{}( const          DT *          *);
     841forall( dtype DT ) void ^?{}( const          DT * volatile *);
     842forall( dtype DT ) void ^?{}(      volatile  DT *          *);
     843forall( dtype DT ) void ^?{}(      volatile  DT * volatile *);
     844forall( dtype DT ) void ^?{}( const volatile  DT *         *);
     845forall( dtype DT ) void ^?{}( const volatile  DT * volatile *);
     846
     847void    ^?{}(               void *          *);
     848void    ^?{}(               void * volatile *);
     849void    ^?{}( const         void *          *);
     850void    ^?{}( const         void * volatile *);
     851void    ^?{}(      volatile void *          *);
     852void    ^?{}(      volatile void * volatile *);
     853void    ^?{}( const volatile void *         *);
     854void    ^?{}( const volatile void * volatile *);
Note: See TracChangeset for help on using the changeset viewer.