Changeset 54af365


Ignore:
Timestamp:
Mar 15, 2024, 7:52:31 PM (9 months ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
master
Children:
33807a1e
Parents:
223b631
Message:

fix convert function for float-point values, add isspace-like routines for C arrays

Location:
libcfa/src
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/stdlib.cfa

    r223b631 r54af365  
    1010// Created On       : Thu Jan 28 17:10:29 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Aug 14 18:22:36 2023
    13 // Update Count     : 642
     12// Last Modified On : Fri Mar 15 18:47:28 2024
     13// Update Count     : 685
    1414//
    1515
    … …  
    2424#include <complex.h>                                                                    // _Complex_I
    2525#include <assert.h>
     26#include <ctype.h>
    2627
    2728#pragma GCC visibility push(default)
    … …  
    6566//---------------------------------------
    6667
     68// Cannot overload with singular (isspace) counterparts because they are macros.
     69
     70bool 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
     78bool 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
     86bool 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
     94bool 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
     102bool 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
     110bool 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
     118bool 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
     126bool 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
     134bool 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
     142bool 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
     150bool 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
     158bool 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
     168float _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
     186double _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
     203long 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
    67220forall( T | { T strto( const char sptr[], char * eptr[], int ); } )
    68 T convert( const char sptr[] ) {
     221T convert( const char sptr[] ) {                                                // integral
    69222        char * eptr;
    70223        errno = 0;                                                                                      // reset
    … …  
    72225        if ( errno == ERANGE ) throw ExceptionInst( out_of_range );
    73226        if ( eptr == sptr ||                                                            // conversion failed, no characters generated
    74                  *eptr != '\0' ) throw ExceptionInst( invalid_argument ); // not at end of str ?
     227                 eptr[0] != '\0' && ! isspaces( eptr ) ) throw ExceptionInst( invalid_argument ); // not at end of blank str ?
    75228        return val;
    76229} // convert
    77230
    78 float _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 
    89 double _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 
    100 long 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
     231forall( T | { T strto( const char sptr[], char * eptr[] ); } )
     232T 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
    110241
    111242//---------------------------------------

  • libcfa/src/stdlib.hfa

    r223b631 r54af365  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Oct  8 09:18:28 2023
    13 // Update Count     : 789
     12// Last Modified On : Fri Mar 15 18:47:26 2024
     13// Update Count     : 792
    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
     297bool isalnums( const char s[] );
     298bool isalphas( const char s[] );
     299bool iscntrls( const char s[] );
     300bool isdigits( const char s[] );
     301bool isgraphs( const char s[] );
     302bool islowers( const char s[] );
     303bool isprints( const char s[] );
     304bool ispuncts( const char s[] );
     305bool isspaces( const char s[] );
     306bool isblanks( const char s[] );
     307bool isuppers( const char s[] );
     308bool isxdigits( const char s[] );
    293309
    294310//---------------------------------------
    … …  
    315331
    316332forall( T | { T strto( const char sptr[], char * eptr[], int ); } )
    317 T convert( const char sptr[] );
     333T convert( const char sptr[] );                                                 // integrals
     334forall( T | { T strto( const char sptr[], char * eptr[] ); } )
     335T convert( const char sptr[] );                                                 // floating-point (no base)
    318336
    319337static inline {
Note: See TracChangeset for help on using the changeset viewer.