Changes in / [3ad5c50:2583407]


Ignore:
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/stdlib.cfa

    r3ad5c50 r2583407  
    1010// Created On       : Thu Jan 28 17:10:29 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 15 18:47:28 2024
    13 // Update Count     : 685
     12// Last Modified On : Mon Aug 14 18:22:36 2023
     13// Update Count     : 642
    1414//
    1515
    … …  
    2424#include <complex.h>                                                                    // _Complex_I
    2525#include <assert.h>
    26 #include <ctype.h>
    2726
    2827#pragma GCC visibility push(default)
    … …  
    6665//---------------------------------------
    6766
    68 // Cannot overload with singular (isspace) counterparts because they are macros.
    69 
    70 bool isalnums( const char s[] ) {
    71         for () {
    72                 if ( *s == '\0' ) return true;
    73                 if ( ! isalnum( *s ) ) return false;
    74                 s += 1;
    75         } // for
    76 } // isalnums
    77 
    78 bool isalphas( const char s[] ) {
    79         for () {
    80                 if ( *s == '\0' ) return true;
    81                 if ( ! isalpha( *s ) ) return false;
    82                 s += 1;
    83         } // for
    84 } // isblanks
    85 
    86 bool iscntrls( const char s[] ) {
    87         for () {
    88                 if ( *s == '\0' ) return true;
    89                 if ( ! iscntrl( *s ) ) return false;
    90                 s += 1;
    91         } // for
    92 } // iscntrls
    93 
    94 bool isdigits( const char s[] ) {
    95         for () {
    96                 if ( *s == '\0' ) return true;
    97                 if ( ! isdigit( *s ) ) return false;
    98                 s += 1;
    99         } // for
    100 } // isdigits
    101 
    102 bool isgraphs( const char s[] ) {
    103         for () {
    104                 if ( *s == '\0' ) return true;
    105                 if ( ! isgraph( *s ) ) return false;
    106                 s += 1;
    107         } // for
    108 } // isgraphs
    109 
    110 bool islowers( const char s[] ) {
    111         for () {
    112                 if ( *s == '\0' ) return true;
    113                 if ( ! islower( *s ) ) return false;
    114                 s += 1;
    115         } // for
    116 } // islowers
    117 
    118 bool isprints( const char s[] ) {
    119         for () {
    120                 if ( *s == '\0' ) return true;
    121                 if ( ! isprint( *s ) ) return false;
    122                 s += 1;
    123         } // for
    124 } // isprints
    125 
    126 bool ispuncts( const char s[] ) {
    127         for () {
    128                 if ( *s == '\0' ) return true;
    129                 if ( ! ispunct( *s ) ) return false;
    130                 s += 1;
    131         } // for
    132 } // ispuncts
    133 
    134 bool isspaces( const char s[] ) {
    135         for () {
    136                 if ( *s == '\0' ) return true;
    137                 if ( ! isspace( *s ) ) return false;
    138                 s += 1;
    139         } // for
    140 } // isspaces
    141 
    142 bool isblanks( const char s[] ) {
    143         for () {
    144                 if ( *s == '\0' ) return true;
    145                 if ( ! isblank( *s ) ) return false;
    146                 s += 1;
    147         } // for
    148 } // isblanks
    149 
    150 bool isuppers( const char s[] ) {
    151         for () {
    152                 if ( *s == '\0' ) return true;
    153                 if ( ! isupper( *s ) ) return false;
    154                 s += 1;
    155         } // for
    156 } // isuppers
    157 
    158 bool isxdigits( const char s[] ) {
    159         for () {
    160                 if ( *s == '\0' ) return true;
    161                 if ( ! isxdigit( *s ) ) return false;
    162                 s += 1;
    163         } // for
    164 } // isxdigits
    165 
    166 //---------------------------------------
    167 
    168 float _Complex strto( const char sptr[], char * eptr[] ) {
    169         float re, im;
    170         char * eeptr;
    171         errno = 0;                                                                                      // reset
    172         re = strtof( sptr, &eeptr );
    173         if ( sptr != eeptr ) {
    174                 im = strtof( eeptr, &eeptr );
    175                 if ( sptr != eeptr ) {
    176                         if ( *eeptr == 'i' ) {
    177                                 if ( eptr != 0p ) *eptr = eeptr + 1;
    178                                 return re + im * _Complex_I;
    179                         } // if
    180                 } // if
    181         } // if
    182         if ( eptr != 0p ) *eptr = eeptr;                                        // error case
    183         return 0.0f + 0.0f * _Complex_I;
    184 } // strto
    185 
    186 double _Complex strto( const char sptr[], char * eptr[] ) {
    187         double re, im;
    188         char * eeptr;
    189         re = strtod( sptr, &eeptr );
    190         if ( sptr != eeptr ) {
    191                 im = strtod( eeptr, &eeptr );
    192                 if ( sptr != eeptr ) {
    193                         if ( *eeptr == 'i' ) {
    194                                 if ( eptr != 0p ) *eptr = eeptr + 1;
    195                                 return re + im * _Complex_I;
    196                         } // if
    197                 } // if
    198         } // if
    199         if ( eptr != 0p ) *eptr = eeptr;                                        // error case
    200         return 0.0 + 0.0 * _Complex_I;
    201 } // strto
    202 
    203 long double _Complex strto( const char sptr[], char * eptr[] ) {
    204         long double re, im;
    205         char * eeptr;
    206         re = strtold( sptr, &eeptr );
    207         if ( sptr != eeptr ) {
    208                 im = strtold( eeptr, &eeptr );
    209                 if ( sptr != eeptr ) {
    210                         if ( *eeptr == 'i' ) {
    211                                 if ( eptr != 0p ) *eptr = eeptr + 1;
    212                                 return re + im * _Complex_I;
    213                         } // if
    214                 } // if
    215         } // if
    216         if ( eptr != 0p ) *eptr = eeptr;                                        // error case
    217         return 0.0L + 0.0L * _Complex_I;
    218 } // strto
    219 
    22067forall( T | { T strto( const char sptr[], char * eptr[], int ); } )
    221 T convert( const char sptr[] ) {                                                // integral
     68T convert( const char sptr[] ) {
    22269        char * eptr;
    22370        errno = 0;                                                                                      // reset
    … …  
    22572        if ( errno == ERANGE ) throw ExceptionInst( out_of_range );
    22673        if ( eptr == sptr ||                                                            // conversion failed, no characters generated
    227                  eptr[0] != '\0' && ! isspaces( eptr ) ) throw ExceptionInst( invalid_argument ); // not at end of blank str ?
     74                 *eptr != '\0' ) throw ExceptionInst( invalid_argument ); // not at end of str ?
    22875        return val;
    22976} // convert
    23077
    231 forall( T | { T strto( const char sptr[], char * eptr[] ); } )
    232 T convert( const char sptr[] ) {                                                // floating-point
    233         char * eptr;
    234         errno = 0;                                                                                      // reset
    235         T val = strto( sptr, &eptr );                                           // attempt conversion
    236         if ( errno == ERANGE ) throw ExceptionInst( out_of_range );
    237         if ( eptr == sptr ||                                                            // conversion failed, no characters generated
    238                  eptr[0] != '\0' && ! isspaces( eptr ) ) throw ExceptionInst( invalid_argument ); // not at end of blank str ?
    239         return val;
    240 } // convert
     78float _Complex strto( const char sptr[], char * eptr[] ) {
     79        float re, im;
     80        char * eeptr;
     81        re = strtof( sptr, &eeptr );
     82        if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
     83        im = strtof( eeptr, &eeptr );
     84        if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
     85        if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
     86        return re + im * _Complex_I;
     87} // strto
     88
     89double _Complex strto( const char sptr[], char * eptr[] ) {
     90        double re, im;
     91        char * eeptr;
     92        re = strtod( sptr, &eeptr );
     93        if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
     94        im = strtod( eeptr, &eeptr );
     95        if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
     96        if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
     97        return re + im * _Complex_I;
     98} // strto
     99
     100long double _Complex strto( const char sptr[], char * eptr[] ) {
     101        long double re, im;
     102        char * eeptr;
     103        re = strtold( sptr, &eeptr );
     104        if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
     105        im = strtold( eeptr, &eeptr );
     106        if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
     107        if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
     108        return re + im * _Complex_I;
     109} // strto
    241110
    242111//---------------------------------------

  • libcfa/src/stdlib.hfa

    r3ad5c50 r2583407  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 15 18:47:26 2024
    13 // Update Count     : 792
     12// Last Modified On : Sun Oct  8 09:18:28 2023
     13// Update Count     : 789
    1414//
    1515
    … …  
    291291forall( T & | sized(T) | { void ^?{}( T & ); } ) void adelete( T arr[] );
    292292forall( T & | sized(T) | { void ^?{}( T & ); }, TT... | { void adelete( TT ); } ) void adelete( T arr[], TT rest );
    293 //---------------------------------------
    294 
    295 // Cannot overload with singular (isspace) counterparts because they are macros.
    296 
    297 bool isalnums( const char s[] );
    298 bool isalphas( const char s[] );
    299 bool iscntrls( const char s[] );
    300 bool isdigits( const char s[] );
    301 bool isgraphs( const char s[] );
    302 bool islowers( const char s[] );
    303 bool isprints( const char s[] );
    304 bool ispuncts( const char s[] );
    305 bool isspaces( const char s[] );
    306 bool isblanks( const char s[] );
    307 bool isuppers( const char s[] );
    308 bool isxdigits( const char s[] );
    309293
    310294//---------------------------------------
    … …  
    331315
    332316forall( T | { T strto( const char sptr[], char * eptr[], int ); } )
    333 T convert( const char sptr[] );                                                 // integrals
    334 forall( T | { T strto( const char sptr[], char * eptr[] ); } )
    335 T convert( const char sptr[] );                                                 // floating-point (no base)
     317T convert( const char sptr[] );
    336318
    337319static inline {

  • tests/.expect/ato.x64.txt

    r3ad5c50 r2583407  
    33-123 -123
    44123 123
    5 -123 -123 
    6 123 123 
     5-123 -123
     6123 123
    77-123.456 -123.456
    88-123.456789012346 -123.4567890123456
    9 -123.456789012345679 -123.45678901234567890123456789 
     9-123.456789012345679 -123.45678901234567890123456789
    1010-123.456-123.456i -123.456-123.456i
    1111-123.456789012346+123.456789012346i -123.4567890123456+123.4567890123456i
    1212123.456789012345679-123.456789012345679i 123.45678901234567890123456789-123.45678901234567890123456789i
    13 123.45678901234-123.456789i 123.45678901234 -123.4567890i
     13123.45678901234-123.456789i 123.45678901234-123.4567890i
    1414-123 -123
    1515123 123
    1616-123 -123
    1717123 123
    18 -123 -123 
    19 123 123 
     18-123 -123
     19123 123
    2020-123.456 -123.456
    2121-123.456789012346 -123.4567890123456
    22 -123.456789012345679 -123.45678901234567890123456789 
     22-123.456789012345679 -123.45678901234567890123456789
    2323-123.456-123.456i -123.456-123.456i
    24 -123.456789012346+123.456789012346i -123.4567890123456+123.4567890123456i
    25 123.456789012345679-123.456789012345679i 123.45678901234567890123456789-123.45678901234567890123456789i
    26 123.45678901234-123.456789i 123.45678901234 -123.4567890i
    27 invalid argument 2.0fred
    28 invalid argument 2  3x
    29 -123 -123
    30 123 123
    31 -123 -123
    32 123 123
    33 -123 -123
    34 123 123
    35 -123.456 -123.456
    36 -123.456789012346 -123.4567890123456
    37 -123.456789012345679 -123.45678901234567890123456789
    38 -123.456-123.456i -123.456-123.456i
     240.+0.i 2  3
    3925-123.456789012346+123.456789012346i -123.4567890123456+123.4567890123456i
    4026123.456789012345679-123.456789012345679i 123.45678901234567890123456789-123.45678901234567890123456789i
    4127123.45678901234-123.456789i 123.45678901234-123.4567890i
    42 invalid argument 2.0fred
    43 invalid argument 2  3x

  • tests/ato.cfa

    r3ad5c50 r2583407  
    1010// Created On       : Thu Feb  4 08:10:57 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 15 17:58:35 2024
    13 // Update Count     : 145
     12// Last Modified On : Tue Dec  4 21:33:53 2018
     13// Update Count     : 92
    1414//
    1515
    … …  
    1818
    1919int main( void ) {
    20         // ato
    21 
    2220        const char * sptr = "-123";
    2321        int i = ato( sptr );
    … …  
    3432        sout | uli | sptr;
    3533
    36         sptr = " -123 ";                                                                        // spaces allowed
     34        sptr = "-123";
    3735        long long int lli = ato( sptr );
    3836        sout | lli | sptr;
    39         sptr = " 123 ";                                                                         // spaces allowed
     37        sptr = "123";
    4038        unsigned long long int ulli = ato( sptr );
    4139        sout | ulli | sptr;
    … …  
    4745        double d = ato( sptr );
    4846        sout | d | sptr;
    49         sptr = " -123.45678901234567890123456789 ";                     // spaces allowed
     47        sptr = "-123.45678901234567890123456789";
    5048        long double ld = ato( sptr );
    5149        sout | ld | sptr;
    … …  
    6058        long double _Complex ldc = ato( sptr );
    6159        sout | ldc | sptr;
    62         sptr = " 123.45678901234 -123.4567890i ";                       // spaces allowed
     60        sptr = "123.45678901234-123.4567890i";
    6361        long double _Complex ldc2 = ato( sptr );
    6462        sout | ldc2 | sptr;
    6563
    66         // strto
    6764
    6865        sptr = "-123";
    69         i = strto( sptr, 0p, 10 );
     66        i = strto( sptr, 0, 10 );
    7067        sout | i | sptr;
    7168        sptr = "123";
    72         ui = strto( sptr, 0p, 10 );
     69        ui = strto( sptr, 0, 10 );
    7370        sout | ui | sptr;
    7471
    7572        sptr = "-123";
    76         li = strto( sptr, 0p, 10 );
     73        li = strto( sptr, 0, 10 );
    7774        sout | li | sptr;
    7875        sptr = "123";
    79         uli = strto( sptr, 0p, 10 );
     76        uli = strto( sptr, 0, 10 );
    8077        sout | uli | sptr;
    8178
    82         sptr = " -123 ";                                                                        // spaces allowed
    83         lli = strto( sptr, 0p, 10 );
     79        sptr = "-123";
     80        lli = strto( sptr, 0, 10 );
    8481        sout | lli | sptr;
    85         sptr = " 123 ";                                                                         // spaces allowed
    86         ulli = strto( sptr, 0p, 10 );
     82        sptr = "123";
     83        ulli = strto( sptr, 0, 10 );
    8784        sout | ulli | sptr;
    8885
    8986        sptr = "-123.456";
    90         f = strto( sptr, 0p );
     87        f = strto( sptr, 0 );
    9188        sout | f | sptr;
    9289        sptr = "-123.4567890123456";
    93         d = strto( sptr, 0p );
     90        d = strto( sptr, 0 );
    9491        sout | d | sptr;
    95         sptr = " -123.45678901234567890123456789 ";                     // spaces allowed
    96         ld = strto( sptr, 0p );
     92        sptr = "-123.45678901234567890123456789";
     93        ld = strto( sptr, 0 );
    9794        sout | ld | sptr;
    9895
    9996        sptr = "-123.456-123.456i";
    100         fc = strto( sptr, 0p );
     97        fc = strto( sptr, 0 );
    10198        sout | fc | sptr;
     99
     100        char * eptr = 0;
     101        // sptr = "2fred";
     102        // fc = strto( sptr, &eptr );
     103        // sout | fc | sptr | eptr;
     104
     105        sptr = "2  3";
     106        fc = strto( sptr, &eptr );
     107        sout | fc | sptr | eptr;
     108
    102109        sptr = "-123.4567890123456+123.4567890123456i";
    103         dc = strto( sptr, 0p );
     110        dc = strto( sptr, 0 );
    104111        sout | dc | sptr;
    105112        sptr = "123.45678901234567890123456789-123.45678901234567890123456789i";
    106         ldc = strto( sptr, 0p );
    107         sout | ldc | sptr;
    108         sptr = " 123.45678901234 -123.4567890i ";                       // spaces allowed
    109         ldc2 = strto( sptr, 0p );
    110         sout | ldc2 | sptr;
    111 
    112         sptr = "2.0fred";
    113         char * eptr = 0p;
    114         errno = 0;                                                                                      // reset
    115         f = strto( sptr, &eptr );
    116         if ( errno == ERANGE ) sout | "out of range";
    117         if ( eptr == sptr ||                                                            // conversion failed, no characters generated
    118                  *eptr != '\0' ) sout | "invalid argument" | sptr; // not at end of str ?
    119         else assert( false );
    120 
    121         sptr = "2  3x";
    122         eptr = 0p;
    123         errno = 0;                                                                                      // reset
    124         fc = strto( sptr, &eptr );
    125         if ( errno == ERANGE ) sout | "out of range";
    126         if ( eptr == sptr ||                                                            // conversion failed, no characters generated
    127                  *eptr != '\0' ) sout | "invalid argument" | sptr; // not at end of str ?
    128         else assert( false );
    129 
    130         // convert
    131 
    132         sptr = "-123";
    133         i = convert( sptr );
    134         sout | i | sptr;
    135         sptr = "123";
    136         ui = convert( sptr );
    137         sout | ui | sptr;
    138 
    139         sptr = "-123";
    140         li = convert( sptr );
    141         sout | li | sptr;
    142         sptr = "123";
    143         uli = convert( sptr );
    144         sout | uli | sptr;
    145 
    146         sptr = " -123 ";                                                                        // spaces allowed
    147         lli = convert( sptr );
    148         sout | lli | sptr;
    149         sptr = " 123 ";                                                                         // spaces allowed
    150         ulli = convert( sptr );
    151         sout | ulli | sptr;
    152 
    153         sptr = "-123.456";
    154         f = convert( sptr );
    155         sout | f | sptr;
    156         sptr = "-123.4567890123456";
    157         d = convert( sptr );
    158         sout | d | sptr;
    159         sptr = " -123.45678901234567890123456789 ";                     // spaces allowed
    160         ld = convert( sptr );
    161         sout | ld | sptr;
    162 
    163         sptr = "-123.456-123.456i";
    164         fc = convert( sptr );
    165         sout | fc | sptr;
    166         sptr = "-123.4567890123456+123.4567890123456i";
    167         dc = convert( sptr );
    168         sout | dc | sptr;
    169         sptr = "123.45678901234567890123456789-123.45678901234567890123456789i";
    170         ldc = convert( sptr );
     113        ldc = strto( sptr, 0 );
    171114        sout | ldc | sptr;
    172115        sptr = "123.45678901234-123.4567890i";
    173         ldc2 = convert( sptr );
     116        ldc2 = strto( sptr, 0 );
    174117        sout | ldc2 | sptr;
    175 
    176         sptr = "2.0fred";
    177         try {
    178                 f = convert( sptr );
    179                 assert( false );
    180         } catch( invalid_argument * ) {
    181                 sout | "invalid argument" | sptr;
    182         } // try
    183 
    184         sptr = "2  3x";
    185         try {
    186                 fc = convert( sptr );
    187                 assert( false );
    188         } catch( invalid_argument * ) {
    189                 sout | "invalid argument" | sptr;
    190         } // try
    191118} // main
    192119
Note: See TracChangeset for help on using the changeset viewer.