strnum.cpp

Go to the documentation of this file.

// strnum.cpp   (c) 2019 adolfo.dimare@gmail.com
 
/** \file  strnum.cpp
    \brief Complement routines for \c <string> && \c <cstring>
 
    \author adolfo.dimare@gmail.com
    \date   2019
*/
 
#include "strnum.h"
 
#include <iostream>
/** Insert in place the separator 'sep' for a numeric string.
    - The string is changed in place and its length remains the same.
    - Skips leading non numerics but handles correctly the sign '-' '+'
      if it inmediatly preceeds the first digit of the number.
    - Leading zeroes ('0') are treated as significant digits.
    - The space for the separators is taken from the beginning of 'num'.
    - Returns a pointer to the first digit (or sign) in the resulting
      string.
    - The characters to the left of the number get overwritten to make
      space for the separator.
    - The number in the string is extended to the left to make rooom for
      the separators.
    - The separator in put in place every 'w' digits, counting from the
      last digit.
    - To insert the comma ',' as the thousand separator use this:
      - <code>char *first = insnsep( num, ',' ,3 );</code>
    - On error, returns NULL and does not change 'num'. There are
      several error conditions:
      - When there is not enough room in the left of the string to
        insert the separator(s) returns NULL.
      - When ( w==0 ) returns NULL.
      - When 'num' does not have any digits to work on returns NULL.
      - When num==NULL returns NULL
    - String 'num' always remains unchanged when NULL is returned.
 
    \dontinclude strnum_test.cpp
    \skipline    test::insnsep()
    \until       }}
*/
char *insnsep( char* num, char sep, unsigned w ) {
    char *first,*from,*to;
    size_t nSkip,nDig,nSep,nLead;
 
    if ( num==NULL ) { return NULL; }
    if ( w==0 ) { return NULL; }
    first=num; nSkip=0;
    while (*first!=0) { // find first digit in [0:9]
        if ( '0'<=*first && *first<='9' ) { break; }
        ++nSkip; ++first;
    }
    if (*first==0) { return NULL; } // no digits
 
    from=first; nDig=0;
    while ('0'<=*from && *from<='9' ) { // count digits in [0:9]
        ++from; ++nDig;
    }
 
    if (w==1) { nSep=nDig-1; nLead=1; }
    else {
        nSep  = nDig/w; // # separators to insert
        nLead = nDig%w; // # digits before first separator
        if (nLead==0) { --nSep; nLead=w; }
    }
    if (nSkip>0) if (*(first-1)=='-' || '+'==*(first-1)) {
        --first; --nSkip; ++nLead; // handle sign
    }
 
    // check that there is enough room to insert all separators
    if ( nSep>nSkip ) { return NULL; }
 
    from   = first;
    first -= nSep;     // move this much to the left
    to     = first;    // where to copy next char
    while ( to!=from ) {  // [nSep==0] ==> [to==from]
        *to = *from;
        ++to; ++from; --nLead;
        if ( nLead==0 ) {
            *to = sep; ++to; // insert another separator
            nLead = w;
        }
    }
    return first;
}
 
/** Use 'insnsep()' to format a Rupee amount.
    - Returns NULL to signal error conditions. In this case, 'num'
      remains unchanged.
      \see http://di-mare.com/adolfo/p/mnyfmt.htm#fg-13
    - Returns NULL to signal error conditions. In this case, 'num'
      remains unchanged.
 
    \dontinclude strnum_test.cpp
    \skipline    test::insnsep_Rupee()
    \until       }}
*/
char* insnsep_Rupee( char *num, char sep ) {
    char *last, *first=num;
    if (num==NULL) { return NULL; }
    while (*first!=0) { // find first digit in [0:9]
        if ( '0'<=*first && *first<='9' ) { break; }
        ++first;
    }
    if (*first==0) { return NULL; }
    last = first;
    while ( '0'<=*last && *last<='9' ) { // find last digit in [0:9]
        ++last;
    }
 
    --last; // no danger because *first is a digit
    {
       char remember = *last;
       *last = 0;
       first = insnsep(num,sep,2);
       *last = remember;
    }
    return first;
}
 
/** Use 'insnsep()' to format a date.
    - Requieres at least 8 digits to format.
    - Ignores the sign '-' '+'.
    - When 'YMD' is 'true' the first 4 digits will be assumed to be the
      year, otherwise the last 4 digits are the year.
      \see http://en.wikipedia.org/wiki/Date_format_by_country
    - Returns NULL to signal error conditions. In this case, 'num'
      remains unchanged.
 
    \dontinclude strnum_test.cpp
    \skipline    test::insnsep_date8()
    \until       }}
*/
char* insnsep_date8( char *num, char sep, bool YMD ) {
    char *from, *first=num;
    size_t n;
    if (num==NULL) { return NULL; }
    while (*first!=0) { // find first digit in [0:9]
        if ( '0'<=*first && *first<='9' ) { break; }
        ++n; ++first;
    }
    if ( ( n<2 ) ) { return NULL; }
    if (*first==0) { return NULL; }
 
    from=first; n=0;
    while ('0'<=*from && *from<='9' ) { // count digits in [0:9]
        ++from; ++n;
    }
    if ( n<8 ) { return NULL; }
 
    first -= 2; // make room for separator
    if ( YMD ) { // YMD && YDM          // "..01235687..."
        memmove( first+0, first+2, 4 ); // "0123..5678..."
        *(first+4) = sep;               // "0123/.5678..."
        memmove( first+5, first+6, 2 ); // "0123/56.78..."
        *(first+7) = sep;               // "0123/56/78..."
    }
    else { // DMY MDY
        memmove( first+0, first+2, 2 ); // "..01346789..."
        *(first+2) = sep;               // "01/.346789..."
        memmove( first+3, first+4, 2 ); // "01/34.6789.."
        *(first+5) = sep;               // "01/34/6789..."
    }
    return first;  // it's easier to memmove() than to insnsep()
}
 
/** Takes all leading numeric values from 'str' to fill up 'VEC[]'.
    - Ignores any dot '.' and every negative number sign '-'.
    - Numbers in 'str' should be separated by any "non digits".
    - Stores up to 'N' number in 'VEC[]'.
    - Requires 'sizeof(VEC[])<=N*sizeof(VEC[0])'.
    - Returns the number of values it stores in 'VEC[]'.
 
    \dontinclude strnum_test.cpp
    \skipline    test::atou_vec()
    \until       }}
*/
size_t atou_vec( const char* str, uintmax_t VEC[], size_t N ) {
    size_t i=0; // [i=0 -> N[
    uintmax_t val;
    while ( i<N ) {
        if ( *str==0 ) { break; }
        while (*str!=0) { // skip !isdigit()
            if ( '0'<=*str && *str<='9' ) { break; }
            else { ++str; }
        }
        if ( *str==0 ) { break; }
 
        val = 0;
        while ( '0'<=*str && *str<='9' ) {
            val = 10*val + (*str-'0');
            ++str;
        }
        VEC[i] = val;
        ++i;
    }
    return i;
}
 
/** Take all numeric values from 'str' to fill up 'VEC[]'.
    - Numbers in 'str' should be separated by any "non numerics".
    - Handles negative numbers with negative number sign '-'.
    - For negative numbers, the negative number sign '-' must
      immediately preceded its digits.
    - Dot '.' is ignored (no floating point).
    - Stores up to 'N' number in 'VEC[]'.
    - Requires 'sizeof(VEC[])<=N*sizeof(VEC[0])'.
    - Returns the number of values it stores in 'VEC[]'.
 
    \dontinclude strnum_test.cpp
    \skipline    test::atoi_vec()
    \until       }}
*/
size_t atoi_vec( const char *str, intmax_t VEC[], size_t N ) {
    bool isNegative = false;
    size_t i=0; // [i=0 -> N[
    uintmax_t val;
    while ( i<N ) {
        if ( *str==0 ) { break; }
        while (*str!=0) { // skip !isdigit()
            if ( '0'<=*str && *str<='9' ) { break; }
            else if ( '-' == *str ) {
                ++str;
                if ( 0==*str ) { break; } // '-' is last char in 'str'
                else if ( '0'<=*str && *str<='9' ) { // '-' before digit
                    isNegative = true;
                    break;
                }
            }
            else { ++str; }
        }
        if ( *str==0 ) { break; }
 
        val = 0;
        while ( '0'<=*str && *str<='9' ) {
            val = 10*val + (*str-'0');
            ++str;
        }
        VEC[i] = ( isNegative ? -val : val );
        isNegative = false;
        ++i;
    }
    return i;
}
 
/** Extract the next number of 'N' digits from '*str'.
    - Skips over leading non digit characteres ['0'..'9'].
    - Only extracts consecutive digits.
    - Skips over the sign '-'.
    - Numbers in '*str' should be separated by any "non numerics".
    - If the number is too big it wont fit in a 'uintmax_t'.
    - Updates '*str' so that it points to the next character after
      the last digit returned.
    - Returns zero (0) if there are no further digits in '*str'.
 
    \dontinclude strnum_test.cpp
    \skipline    test::atou_ndigit()
    \until       }}
*/
uintmax_t atou_ndigit( const char* *str, unsigned N ) {
    if (str==0)  { return 0; }
    if (*str==0) { return 0; }
    uintmax_t val=0;
    while (**str!=0) { // skip !isdigit()
        if ( '0'<=**str && **str<='9' ) { break; }
        else { ++(*str); }
    }
    if ( **str==0 ) {
        return 0;
    }
    while ( '0'<=**str && **str<='9' && N>0 ) {
        val = 10*val + (**str-'0');
        --N;
        ++(*str);
    }
 
    return val;
}
/*  Extrae el siguiente valor numérico de 'N' dígitos de '*str'.
    - Se brinca caracteres que no son dígitos ['0'..'9'].
    - Solo usa dígitos consecutivos.
    - Se brinca el signo '-'.
    - Si 'N' es muy grande, el valor retornado no cabe en 'uintmax_t'.
    - Actualiza '*str' para que apunte al siguiente caracter después del
      último dígito del valor retornado 'num'.
    - Retorna cero (0) si no hay más dígitos en '*str'.
*/
 
/** Converts 'val' into the zero terminated C-string 'dst'.
    - 'dst' is converted to a 'base' numeric value.
    - 'dst' must have at least 'sz' char's (including eos=0x0).
    - Usually 'dst[] is an array where 'sz==sizeof( dst[] )'.
    - Returns a pointer to the first non zero within 'dst'.
    - Fills up with '0' the non significant digits in 'dst'.
    - [Usually does not return 'dst'].
    \pre (val>=0) && (base>0) && (len>0) && 'dst' must be big enough.
 
    \dontinclude strnum_test.cpp
    \skipline    test::utoa_sz()
    \until       }}
*/
 
char* utoa_sz( uintmax_t val, char *dst, unsigned base, size_t sz ) {
    unsigned dgt;
    char *p;
    if ( dst!=0 && (base>0) && (sz>1) ) { /* OK */ }
    else { /* *dst = 0 */ ; return dst; }
    #if !defined(NDEBUG)
        if ( (val>=0) ) { /* OK */ }
        else { /* *dst = 0 */ ; return dst; }
    #endif
    --sz;
    p = dst+sz;  *p = 0; // EOS
    do {
        --p;
        dgt = val % base;
        val = val / base;
        *p = dgt + '0';
        --sz;
    } while ( val!=0 && p!=dst );
 
    if (p!=dst) {
        for ( char* lead=p-1; sz>0; --sz ) {
            *lead = '0'; --lead;
        }
    }
    return p;
}
 
// std::cout << num << "->(nSkip,nDig,nSep,nLead)==("
// << nSkip << ',' << nDig  << ',' << nSep  << ',' << nLead<< ")\n";
// std::cout << to << " -> " << from << '\n';
 
#if 0 /* OLD CODE */
 
/** Use 'insnsep()' to format a date.
    - Requieres exactly 8 digits to format.
    - When 'YMD' is 'true' the first 4 digits will be assumed to be the
      year, otherwise the last 4 digits are presummed to be the year.
      \see http://en.wikipedia.org/wiki/Date_format_by_country
    - Returns NULL to signal error conditions. In this case, 'num'
      remains unchanged.
 
    \dontinclude strnum_test.cpp
    \skipline    test::insnsep_date8()
    \until       }}
*/
char* insnsep_date8_old( char *num, char sep, bool YMD ) {
    char *from, *first=num;
    size_t n;
    if (num==NULL) { return NULL; }
    while (*first!=0) { // find first digit in [0:9]
        if ( '0'<=*first && *first<='9' ) { break; }
        ++n; ++first;
    }
    if ( ( n<2 ) ) { return NULL; }
    if (*first==0) { return NULL; }
 
    from=first; n=0;
    while ('0'<=*from && *from<='9' ) { // count digits in [0:9]
        ++from; ++n;
    }
    if ( n!=8 ) { return NULL; }
 
    /*=/=*/ first = insnsep( num, sep, 4 );
    --first;
    if ( YMD ) {    // " 1234/67:89..."
        memmove( first ,first+1, 7 ); *(first+7) = sep;
    }
    else {          // " 12:45/6789..."
        memmove( first ,first+1, 2 ); *(first+2) = sep;
    }
    return first;
}
 
/*  Converts 'str' into an unsigned number.
    - Uses the numeric prefix of \c str.
    - Ignores the negative number sign '-'.
 
    \dontinclude strnum_test.cpp
    \skipline    test::atouint()
    \until       }}
*/
uintmax_t atouint( const char * str ) {
    return strtoull( str,NULL,0);
}
 
size_t atoi_vec_old( const char *str, intmax_t VEC[], size_t N ) {
    size_t LEN = strlen( str );
    bool isNegative = false;
    size_t k = 0;   // index into str
    size_t nxt = 0; // index into VEC[]
    while ( k<LEN && nxt<N  ) {
        while ( k<LEN  ) { // skip leading non numeric
            if ( ('0'<=str[k] && str[k]<='9') ) { break; } // isdigit()
            else if ( '-'==str[k] ) { // negative number
                if ( k>=LEN-1 ) { // '-' is the last char in 'str'
                    k = LEN; break;
                }
                else if ( ('0'<=str[k+1] && str[k+1]<='9') ) {
                    ++k; // '-' before digit
                    isNegative = true;
                    break;
                }
            }
            ++k;
        }
        if ( k==LEN ) { break; }
 
        int val = 0; // now convert digits
        while ( ('0'<=str[k] && str[k]<='9') ) {
            val = 10*val + (str[k]-'0');
            ++k;
            if (k==LEN) { break; }
        }
        VEC[nxt] = ( isNegative ? -val : val );
        isNegative = false;
        ++nxt;
    }
    return nxt;
}
 
/** Extrae los primeros 'N' números de 'str'.
    - Se brinca caracteres que no son dígitos ['0'..'9'].
    - Solo usa dígitos consecutivos.
    - Se brinca el signo '-'.
    - VEC[] debe tener capacidad de almacenar al menos 'N' números.
    - Retorna la cantidad de valores grabados en 'VEC[]'.
 
    \dontinclude strnum_test.cpp
    \skipline    test::atou_vec_old()
    \until       }}
*/
size_t atou_vec_old( const char *str, uintmax_t VEC[], size_t N ) {
    size_t LEN = strlen( str );
    size_t k = 0;   // index into str
    size_t nxt = 0; // index into VEC[]
    while ( k<LEN && nxt<N  ) {
        while ( k<LEN  ) { // skip leading non numeric
            if ( ('0'<=str[k] && str[k]<='9') ) { break; }
            ++k;
        }
        if ( k==LEN ) { break; }
 
        // convert digits
        uintmax_t val = 0;
        while ( ('0'<=str[k] && str[k]<='9') ) {
            val = 10*val + (str[k]-'0');
            ++k;
            if (k==LEN) { break; }
        }
        VEC[nxt] = val;
        ++nxt;
    }
    return nxt;
}
 
/// Gets the unsigned numbers in the rest of the current line.
/// Stores the numbers into 'VEC[]'.
/// Counts the numbers it stores and returns it.
size_t atou_vec_UGLY(const char str[], uintmax_t* VEC ) {
    size_t LEN = strlen(str);
    size_t idx=0, i=0, num=0;
    bool inNumber =  true;
 
    i = 0; // skip leading non numeric
    while ( i<LEN  ) {
        if ( ('0'<=str[i] && str[i]<='9') ) { break; }
        ++i;
    }
    if ( i==LEN ) { return 0; }
 
    idx = 0;
    num = 0;
    inNumber = true;
    while ( i<LEN  ) {
        if ( inNumber ) {
            if ( ('0'<=str[i] && str[i]<='9') ) { // isdigit()
                num = num * 10 + (str[i]-'0');
            }
            else {
                VEC[idx] = num; num=0;
                ++idx;
                inNumber = false;
            }
        }
        else {
            if ( ('0'<=str[i] && str[i]<='9') ) {
                num = num * 10 + (str[i]-'0');
                inNumber = true;
            }
        }
        ++i;
    }
    if ( inNumber ) { VEC[idx] = num; ++idx; }
    return idx;
}
 
uintmax_t atouint_old( const char * str ) {
    size_t i = 0;
    size_t N = strlen(str);
    while ( i<N ) { // skip leading non numeric
        if ( ! ('0'<=str[i] && str[i]<='9') ) { ++i; } // !isdigit()
        else { break; }
    }
 
    uintmax_t n=0;
    while ( i<N ) {
        if ( ! ('0'<=str[i] && str[i]<='9') ) { break; }
        n = 10 * n + (str[i]-'0');
        ++i;
    }
    return n;
}
 
#endif
 
// EOF: strnum.cpp