Ignore:
Timestamp:
Jul 14, 2026, 9:26:24 PM (5 hours ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
master
Children:
a12816e7
Parents:
f41b161
Message:

formatting, turn off -Wdangling-pointer around small code fragments because of false positive

File:
1 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/vec/vec2.hfa

    rf41b161 rc62013e  
    1919#include "vec.hfa"
    2020
    21 forall (T) {
     21forall( T ) {
    2222    struct vec2 {
    2323        T x, y;
    … …  
    2525}
    2626
    27 forall (T) {
    28     static inline {
    29 
    30     void ?{}(vec2(T)& v, T x, T y) {
    31         v.[x, y] = [x, y];
    32     }
    33 
    34     forall(| zero_assign(T))
    35     void ?{}(vec2(T)& vec, zero_t) with (vec) {
    36         x = y = 0;
    37     }
    38 
    39     void ?{}(vec2(T)& vec, T val) with (vec) {
    40         x = y = val;
    41     }
    42 
    43     void ?{}(vec2(T)& vec, vec2(T) other) with (vec) {
    44         [x,y] = other.[x,y];
    45     }
    46 
    47     void ?=?(vec2(T)& vec, vec2(T) other) with (vec) {
    48         [x,y] = other.[x,y];
    49     }
    50     forall(| zero_assign(T))
    51     void ?=?(vec2(T)& vec, zero_t) with (vec) {
    52         x = y = 0;
    53     }
    54 
    55     // Primitive mathematical operations
    56 
    57     // -
    58     forall(| subtract(T)) {
    59     vec2(T) ?-?(vec2(T) u, vec2(T) v) {
    60         return [u.x - v.x, u.y - v.y];
    61     }
    62     vec2(T)& ?-=?(vec2(T)& u, vec2(T) v) {
    63         u = u - v;
    64         return u;
    65     }
    66     }
    67     forall(| negate(T))
    68     vec2(T) -?(vec2(T) v) with (v) {
    69         return [-x, -y];
    70     }
    71 
    72     forall(| { T --?(T&); }) {
    73     vec2(T)& --?(vec2(T)& v) {
    74         --v.x;
    75         --v.y;
    76         return v;
    77     }
    78     vec2(T) ?--(vec2(T)& v) {
    79         vec2(T) copy = v;
    80         --v;
    81         return copy;
    82     }
    83     }
    84 
    85     // +
    86     forall(| add(T)) {
    87     vec2(T) ?+?(vec2(T) u, vec2(T) v) {
    88         return [u.x + v.x, u.y + v.y];
    89     }
    90     vec2(T)& ?+=?(vec2(T)& u, vec2(T) v) {
    91         u = u + v;
    92         return u;
    93     }
    94     }
    95 
    96     forall(| { T ++?(T&); }) {
    97     vec2(T)& ++?(vec2(T)& v) {
    98         ++v.x;
    99         ++v.y;
    100         return v;
    101     }
    102     vec2(T) ?++(vec2(T)& v) {
    103         vec2(T) copy = v;
    104         ++v;
    105         return copy;
    106     }
    107     }
    108 
    109     // *
    110     forall(| multiply(T)) {
    111     vec2(T) ?*?(vec2(T) v, T scalar) with (v) {
    112         return [x * scalar, y * scalar];
    113     }
    114     vec2(T) ?*?(T scalar, vec2(T) v) {
    115         return v * scalar;
    116     }
    117     vec2(T) ?*?(vec2(T) u, vec2(T) v) {
    118         return [u.x * v.x, u.y * v.y];
    119     }
    120     vec2(T)& ?*=?(vec2(T)& v, T scalar) {
    121         v = v * scalar;
    122         return v;
    123     }
    124     vec2(T) ?*=?(vec2(T)& u, vec2(T) v) {
    125         u = u * v;
    126         return u;
    127     }
    128     }
    129 
    130     // /
    131     forall(| divide(T)) {
    132     vec2(T) ?/?(vec2(T) v, T scalar) with (v) {
    133         return [x / scalar, y / scalar];
    134     }
    135     vec2(T) ?/?(vec2(T) u, vec2(T) v) {
    136         return [u.x / v.x, u.y / v.y];
    137     }
    138     vec2(T)& ?/=?(vec2(T)& v, T scalar) {
    139         v = v / scalar;
    140         return v;
    141     }
    142     vec2(T) ?/=?(vec2(T)& u, vec2(T) v) {
    143         u = u / v;
    144         return u;
    145     }
    146     }
    147 
    148     // %
    149     forall(| { T ?%?(T,T); }) {
    150     vec2(T) ?%?(vec2(T) v, T scalar) with (v) {
    151         return [x % scalar, y % scalar];
    152     }
    153     vec2(T)& ?%=?(vec2(T)& u, T scalar) {
    154         u = u % scalar;
    155         return u;
    156     }
    157     vec2(T) ?%?(vec2(T) u, vec2(T) v) {
    158         return [u.x % v.x, u.y % v.y];
    159     }
    160     vec2(T)& ?%=?(vec2(T)& u, vec2(T) v) {
    161         u = u % v;
    162         return u;
    163     }
    164     }
    165 
    166     // &
    167     forall(| { T ?&?(T,T); }) {
    168     vec2(T) ?&?(vec2(T) v, T scalar) with (v) {
    169         return [x & scalar, y & scalar];
    170     }
    171     vec2(T)& ?&=?(vec2(T)& u, T scalar) {
    172         u = u & scalar;
    173         return u;
    174     }
    175     vec2(T) ?&?(vec2(T) u, vec2(T) v) {
    176         return [u.x & v.x, u.y & v.y];
    177     }
    178     vec2(T)& ?&=?(vec2(T)& u, vec2(T) v) {
    179         u = u & v;
    180         return u;
    181     }
    182     }
    183 
    184     // |
    185     forall(| { T ?|?(T,T); }) {
    186     vec2(T) ?|?(vec2(T) v, T scalar) with (v) {
    187         return [x | scalar, y | scalar];
    188     }
    189     vec2(T)& ?|=?(vec2(T)& u, T scalar) {
    190         u = u | scalar;
    191         return u;
    192     }
    193     vec2(T) ?|?(vec2(T) u, vec2(T) v) {
    194         return [u.x | v.x, u.y | v.y];
    195     }
    196     vec2(T)& ?|=?(vec2(T)& u, vec2(T) v) {
    197         u = u | v;
    198         return u;
    199     }
    200     }
    201 
    202     // ^
    203     forall(| { T ?^?(T,T); }) {
    204     vec2(T) ?^?(vec2(T) v, T scalar) with (v) {
    205         return [x ^ scalar, y ^ scalar];
    206     }
    207     vec2(T)& ?^=?(vec2(T)& u, T scalar) {
    208         u = u ^ scalar;
    209         return u;
    210     }
    211     vec2(T) ?^?(vec2(T) u, vec2(T) v) {
    212         return [u.x ^ v.x, u.y ^ v.y];
    213     }
    214     vec2(T)& ?^=?(vec2(T)& u, vec2(T) v) {
    215         u = u ^ v;
    216         return u;
    217     }
    218     }
    219 
    220     // <<
    221     forall(| { T ?<<?(T,T); }) {
    222     vec2(T) ?<<?(vec2(T) v, T scalar) with (v) {
    223         return [x << scalar, y << scalar];
    224     }
    225     vec2(T)& ?<<=?(vec2(T)& u, T scalar) {
    226         u = u << scalar;
    227         return u;
    228     }
    229     vec2(T) ?<<?(vec2(T) u, vec2(T) v) {
    230         return [u.x << v.x, u.y << v.y];
    231     }
    232     vec2(T)& ?<<=?(vec2(T)& u, vec2(T) v) {
    233         u = u << v;
    234         return u;
    235     }
    236     }
    237 
    238     // >>
    239     forall(| { T ?>>?(T,T); }) {
    240     vec2(T) ?>>?(vec2(T) v, T scalar) with (v) {
    241         return [x >> scalar, y >> scalar];
    242     }
    243     vec2(T)& ?>>=?(vec2(T)& u, T scalar) {
    244         u = u >> scalar;
    245         return u;
    246     }
    247     vec2(T) ?>>?(vec2(T) u, vec2(T) v) {
    248         return [u.x >> v.x, u.y >> v.y];
    249     }
    250     vec2(T)& ?>>=?(vec2(T)& u, vec2(T) v) {
    251         u = u >> v;
    252         return u;
    253     }
    254     }
    255 
    256     // ~
    257     forall(| { T ~?(T); })
    258     vec2(T) ~?(vec2(T) v) with (v) {
    259         return [~v.x, ~v.y];
    260     }
    261 
    262     // relational
    263     forall(| equality(T)) {
    264     bool ?==?(vec2(T) u, vec2(T) v) with (u) {
    265         return x == v.x && y == v.y;
    266     }
    267     bool ?!=?(vec2(T) u, vec2(T) v) {
    268         return !(u == v);
    269     }
    270     }
    271 
    272     // Geometric functions
    273     forall(| add(T) | multiply(T))
    274     T dot(vec2(T) u, vec2(T) v) {
    275         return u.x * v.x + u.y * v.y;
    276     }
    277 
    278     } // static inline
    279 }
    280 
    281 forall(ostype &, T | writeable(T, ostype)) {
    282     ostype & ?|?(ostype & os, vec2(T) v) with (v) {
     27static inline forall( T ) {
     28
     29        void ?{}( vec2( T )& v, T x, T y ) {
     30                v.[x, y] = [x, y];
     31        }
     32
     33        forall(| zero_assign( T ))
     34                void ?{}( vec2( T )& vec, zero_t ) with ( vec ) {
     35                x = y = 0;
     36        }
     37
     38        void ?{}( vec2( T )& vec, T val ) with ( vec ) {
     39                x = y = val;
     40        }
     41
     42        void ?{}( vec2( T )& vec, vec2( T ) other ) with ( vec ) {
     43                [x,y] = other.[x,y];
     44        }
     45
     46        void ?=?( vec2( T )& vec, vec2( T ) other ) with ( vec ) {
     47                [x,y] = other.[x,y];
     48        }
     49        forall(| zero_assign( T ))
     50                void ?=?( vec2( T )& vec, zero_t ) with ( vec ) {
     51                x = y = 0;
     52        }
     53
     54        // Primitive mathematical operations
     55
     56        // -
     57        forall(| subtract( T )) {
     58                vec2( T ) ?-?( vec2( T ) u, vec2( T ) v ) {
     59                        return [u.x - v.x, u.y - v.y];
     60                }
     61                vec2( T )& ?-=?( vec2( T )& u, vec2( T ) v ) {
     62                        u = u - v;
     63                        return u;
     64                }
     65        }
     66        forall(| negate( T ))
     67                vec2( T ) -?( vec2( T ) v ) with ( v ) {
     68                return [-x, -y];
     69        }
     70
     71        forall(| { T --?( T&); }) {
     72                vec2( T )& --?( vec2( T )& v ) {
     73                        --v.x;
     74                        --v.y;
     75                        return v;
     76                }
     77                vec2( T ) ?--( vec2( T )& v ) {
     78                        vec2( T ) copy = v;
     79                        --v;
     80                        return copy;
     81                }
     82        }
     83
     84        // +
     85        forall(| add( T )) {
     86                vec2( T ) ?+?( vec2( T ) u, vec2( T ) v ) {
     87                        return [u.x + v.x, u.y + v.y];
     88                }
     89                vec2( T )& ?+=?( vec2( T )& u, vec2( T ) v ) {
     90                        u = u + v;
     91                        return u;
     92                }
     93        }
     94
     95        forall(| { T ++?( T&); }) {
     96                vec2( T )& ++?( vec2( T )& v ) {
     97                        ++v.x;
     98                        ++v.y;
     99                        return v;
     100                }
     101                vec2( T ) ?++( vec2( T )& v ) {
     102                        vec2( T ) copy = v;
     103                        ++v;
     104                        return copy;
     105                }
     106        }
     107
     108        // *
     109        forall(| multiply( T )) {
     110                vec2( T ) ?*?( vec2( T ) v, T scalar ) with ( v ) {
     111                        return [x * scalar, y * scalar];
     112                }
     113                vec2( T ) ?*?( T scalar, vec2( T ) v ) {
     114                        return v * scalar;
     115                }
     116                vec2( T ) ?*?( vec2( T ) u, vec2( T ) v ) {
     117                        return [u.x * v.x, u.y * v.y];
     118                }
     119                vec2( T )& ?*=?( vec2( T )& v, T scalar ) {
     120                        v = v * scalar;
     121                        return v;
     122                }
     123                vec2( T ) ?*=?( vec2( T )& u, vec2( T ) v ) {
     124                        u = u * v;
     125                        return u;
     126                }
     127        }
     128
     129        // /
     130        forall(| divide( T )) {
     131                vec2( T ) ?/?( vec2( T ) v, T scalar ) with ( v ) {
     132                        return [x / scalar, y / scalar];
     133                }
     134                vec2( T ) ?/?( vec2( T ) u, vec2( T ) v ) {
     135                        return [u.x / v.x, u.y / v.y];
     136                }
     137                vec2( T )& ?/=?( vec2( T )& v, T scalar ) {
     138                        v = v / scalar;
     139                        return v;
     140                }
     141                vec2( T ) ?/=?( vec2( T )& u, vec2( T ) v ) {
     142                        u = u / v;
     143                        return u;
     144                }
     145        }
     146
     147        // %
     148        forall(| { T ?%?( T,T ); }) {
     149                vec2( T ) ?%?( vec2( T ) v, T scalar ) with ( v ) {
     150                        return [x % scalar, y % scalar];
     151                }
     152                vec2( T )& ?%=?( vec2( T )& u, T scalar ) {
     153                        u = u % scalar;
     154                        return u;
     155                }
     156                vec2( T ) ?%?( vec2( T ) u, vec2( T ) v ) {
     157                        return [u.x % v.x, u.y % v.y];
     158                }
     159                vec2( T )& ?%=?( vec2( T )& u, vec2( T ) v ) {
     160                        u = u % v;
     161                        return u;
     162                }
     163        }
     164
     165        // &
     166        forall(| { T ?&?( T,T ); }) {
     167                vec2( T ) ?&?( vec2( T ) v, T scalar ) with ( v ) {
     168                        return [x & scalar, y & scalar];
     169                }
     170                vec2( T )& ?&=?( vec2( T )& u, T scalar ) {
     171                        u = u & scalar;
     172                        return u;
     173                }
     174                vec2( T ) ?&?( vec2( T ) u, vec2( T ) v ) {
     175                        return [u.x & v.x, u.y & v.y];
     176                }
     177                vec2( T )& ?&=?( vec2( T )& u, vec2( T ) v ) {
     178                        u = u & v;
     179                        return u;
     180                }
     181        }
     182
     183        // |
     184        forall(| { T ?|?( T,T ); }) {
     185                vec2( T ) ?|?( vec2( T ) v, T scalar ) with ( v ) {
     186                        return [x | scalar, y | scalar];
     187                }
     188                vec2( T )& ?|=?( vec2( T )& u, T scalar ) {
     189                        u = u | scalar;
     190                        return u;
     191                }
     192                vec2( T ) ?|?( vec2( T ) u, vec2( T ) v ) {
     193                        return [u.x | v.x, u.y | v.y];
     194                }
     195                vec2( T )& ?|=?( vec2( T )& u, vec2( T ) v ) {
     196                        u = u | v;
     197                        return u;
     198                }
     199        }
     200
     201        // ^
     202        forall(| { T ?^?( T,T ); }) {
     203                vec2( T ) ?^?( vec2( T ) v, T scalar ) with ( v ) {
     204                        return [x ^ scalar, y ^ scalar];
     205                }
     206                vec2( T )& ?^=?( vec2( T )& u, T scalar ) {
     207                        u = u ^ scalar;
     208                        return u;
     209                }
     210                vec2( T ) ?^?( vec2( T ) u, vec2( T ) v ) {
     211                        return [u.x ^ v.x, u.y ^ v.y];
     212                }
     213                vec2( T )& ?^=?( vec2( T )& u, vec2( T ) v ) {
     214                        u = u ^ v;
     215                        return u;
     216                }
     217        }
     218
     219        // <<
     220        forall(| { T ?<<?( T,T ); }) {
     221                vec2( T ) ?<<?( vec2( T ) v, T scalar ) with ( v ) {
     222                        return [x << scalar, y << scalar];
     223                }
     224                vec2( T )& ?<<=?( vec2( T )& u, T scalar ) {
     225                        u = u << scalar;
     226                        return u;
     227                }
     228                vec2( T ) ?<<?( vec2( T ) u, vec2( T ) v ) {
     229                        return [u.x << v.x, u.y << v.y];
     230                }
     231                vec2( T )& ?<<=?( vec2( T )& u, vec2( T ) v ) {
     232                        u = u << v;
     233                        return u;
     234                }
     235        }
     236
     237        // >>
     238        forall(| { T ?>>?( T,T ); }) {
     239                vec2( T ) ?>>?( vec2( T ) v, T scalar ) with ( v ) {
     240                        return [x >> scalar, y >> scalar];
     241                }
     242                vec2( T )& ?>>=?( vec2( T )& u, T scalar ) {
     243                        u = u >> scalar;
     244                        return u;
     245                }
     246                vec2( T ) ?>>?( vec2( T ) u, vec2( T ) v ) {
     247                        return [u.x >> v.x, u.y >> v.y];
     248                }
     249                vec2( T )& ?>>=?( vec2( T )& u, vec2( T ) v ) {
     250                        u = u >> v;
     251                        return u;
     252                }
     253        }
     254
     255        // ~
     256        forall(| { T ~?( T ); })
     257                vec2( T ) ~?( vec2( T ) v ) with ( v ) {
     258                return [~v.x, ~v.y];
     259        }
     260
     261        // relational
     262        forall(| equality( T )) {
     263                bool ?==?( vec2( T ) u, vec2( T ) v ) with ( u ) {
     264                        return x == v.x && y == v.y;
     265                }
     266                bool ?!=?( vec2( T ) u, vec2( T ) v ) {
     267                        return !( u == v );
     268                }
     269        }
     270
     271        // Geometric functions
     272        forall(| add( T ) | multiply( T ))
     273                T dot( vec2( T ) u, vec2( T ) v ) {
     274                return u.x * v.x + u.y * v.y;
     275        }
     276} // static inline
     277
     278
     279forall( ostype &, T | writeable( T, ostype )) {
     280    ostype & ?|?( ostype & os, vec2( T ) v ) with ( v ) {
    283281        return os | '<' | x | ',' | y | '>';
    284282    }
    285         OSTYPE_VOID_IMPL( os, vec2(T) )
     283        OSTYPE_VOID_IMPL( os, vec2( T ) )
    286284}
Note: See TracChangeset for help on using the changeset viewer.