Changeset 5f210c0 for libcfa


Ignore:
Timestamp:
Aug 4, 2024, 9:49:25 PM (5 months ago)
Author:
JiadaL <j82liang@…>
Branches:
master
Children:
7db4fcd4
Parents:
7ab24fef
Message:

Change enum pos to signed int to avoid underflow; operator on enum will not have range check (but succ and pred still have range check

Location:
libcfa/src
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/enum.cfa

    r7ab24fef r5f210c0  
    66
    77forall( E | Serial( E ) ) {
    8         E fromInt( unsigned i ) {
     8        E fromInt( int i ) {
    99                E upper = upperBound();
    1010                E lower = lowerBound();

  • libcfa/src/enum.hfa

    r7ab24fef r5f210c0  
    99
    1010forall( E | Bounded( E ) ) trait Serial {
    11         unsigned fromInstance( E e );
    12         E fromInt_unsafe( unsigned i );
     11        int fromInstance( E e );
     12        E fromInt_unsafe( int i );
    1313        E succ_unsafe( E e );
    1414        E pred_unsafe( E e );
    … …  
    1616
    1717forall( E | Serial( E ) ) {
    18         E fromInt( unsigned i );
     18        E fromInt( int i );
    1919        E succ( E e );
    2020        E pred( E e );
    … …  
    3636forall( E ) trait CfaEnum {
    3737        const char * label( E e );
    38         unsigned int posn( E e );
     38        int posn( E e );
    3939};
    4040
    … …  
    6363
    6464        E ++?( E & l ) {                                                                        // increment operators
    65                 l = succ( l );
     65                int pos = posn(l);
     66                l = fromInt_unsafe(pos+1);
     67                return l;
     68        }
     69
     70        E --?( E & l ) {
     71                int pos = posn(l);
     72                l = fromInt_unsafe(pos-1);
    6673                return l;
    6774        }
    6875
    6976        E ?+=? ( E & l, one_t ) {
    70                 l = succ(l);
     77                int pos = posn(l);
     78                l = fromInt_unsafe(pos+1);
    7179                return l;
    7280        }
    73        
     81
    7482        E ?-=? ( E & l, one_t ) {
    75                 l = pred(l);
     83                int pos = posn(l);
     84                l = fromInt_unsafe(pos-1);
    7685                return l;
    7786        }
    7887
    7988        E ?+=? ( E & l, int i ) {
    80                 int pos = posn(l) + i;
     89                int pos = posn(l);
     90                l = fromInt_unsafe(pos+i);
    8191                return fromInt(pos);
    8292        }
    8393
    8494        E ?-=? ( E & l, int i ) {
    85                 int pos = posn(l) - i;
    86                 return fromInt(pos);
    87         }
    88        
    89         E ?++( E & l ) {
    90                 E ret = l;
    91                 l = succ( l );
    92                 return ret;
    93         }
    94 
    95         E --?( E & l ) {
    96                 l = pred( l );
     95                int pos = posn(l);
     96                l = fromInt_unsafe(pos-i);
    9797                return l;
    9898        }
    9999
     100        E ?++( E & l ) {
     101                int pos = posn(l);
     102                l = fromInt_unsafe(pos+1);
     103                return fromInt_unsafe(pos);
     104        }
     105
    100106        E ?--( E & l ) {
    101                 E ret = l;
    102                 l = pred( l );
    103                 return ret;
     107                int pos = posn(l);
     108                l = fromInt_unsafe(pos-1);
     109                return fromInt_unsafe(pos);
    104110        }
    105111}
Note: See TracChangeset for help on using the changeset viewer.