%% options copyright owner = Dirk Krause copyright year = 2015-xxxx license = bsd %% header /** @file Retrieve size_t value from 8 bit character string in decimal notation. CRT on Windows: Optional, disabling CRT degrades performance. */ #ifndef DK4CONF_H_INCLUDED #include "dk4conf.h" #endif #ifndef DK4TYPES_H_INCLUDED #include "dk4types.h" #endif #ifndef DK4ERROR_H_INCLUDED #include "dk4error.h" #endif #ifdef __cplusplus extern "C" { #endif /** Retrieve numeric value from string, decimal notation. @param rp Pointer to result variable for the found value. @param src String to check for numeric value. @param endptr Address of pointer variable. A pointer to the first character not processed is stored here. The function may also store a NULL pointer in this variable. The variable points to the correct error position only if er.ec is DK4_E_SYNTAX. @param atg Allow trailing garbage: 0=no unprocessable trailing bytes allowed, 1=trailing whitespaces allowed, 2=any trailing characters allowed. @param erp Error report, may be NULL. @return 1 on success, 0 on error. Error codes: DK4_E_INVALID_ARGUMENTS if rp or src is NULL, DK4_E_MATH_OVERFLOW if the number is out of range, or DK4_E_SYNTAX if src contains illegal characters. */ int dk4ma_input_c8_dec_size_t( size_t *rp, const char *src, const char **endptr, int atg, dk4_er_t *erp ); #ifdef __cplusplus } #endif %% module #include "dk4mai8ddu.h" #include "dk4mai8dsz.h" #include "dk4maasz.h" #include "dk4numco.h" #include "dk4str8.h" #if VERSION_1 /** Find multiplication factor for size. @param str String probably containing a size specification. @param fp Pointer to factor variable. @param erp Error report, may be NULL. @return Start of string after size specification. */ static const char * dk4mai8dsz_find_factor(const char *str, size_t *fp, dk4_er_t *erp) { size_t factor = 1; size_t numl = 0; switch (*str) { case 'k': case 'K': { numl = 1; str++; } break; case 'm': case 'M': { numl = 2; str++; } break; case 'g': case 'G': { numl = 3; str++; } break; case 't': case 'T': { numl = 4; str++; } break; } while (0 < numl--) { #if VERSION_BEFORE_20141007 factor = dk4ma_size_t_mul(factor, 1024, erp); #else if ((SIZE_MAX / 1024) >= factor) { factor *= 1024; } else { dk4error_set_simple_error_code(erp, DK4_E_MATH_OVERFLOW); } #endif } *fp = factor; return str; } /* UNTESTED */ int dk4ma_input_c8_dec_size_t( size_t *rp, const char *src, const char **endptr, int atg, dk4_er_t *erp ) { dk4_er_t er; const char *myend = NULL; dk4_um_t res; size_t szr; size_t factor = 1; int back = 0; if (0 != dk4ma_input_c8_dec_dk4_um_t(&res, src, &myend, 2, erp)) { if (((dk4_um_t)(SIZE_MAX)) >= res) { szr = (size_t)res; if (NULL != myend) { dk4error_init(&er); myend = dk4mai8dsz_find_factor(myend, &factor, &er); if (DK4_E_MATH_OVERFLOW != er.ec) { dk4error_init(&er); #if VERSION_BEFORE_20141107 szr = dk4ma_size_t_mul(szr, factor, &er); #else if ((SIZE_MAX / factor) >= szr) { szr *= factor; } else { dk4error_set_simple_error_code(&er, DK4_E_MATH_OVERFLOW); } #endif if (DK4_E_MATH_OVERFLOW != er.ec) { if ('\0' == *myend) { *rp = szr; back = 1; } else { switch (atg) { case 2: { *rp = szr; back = 1; } break; case 1: { if (NULL == dk4str8_start(myend, NULL)) { *rp = szr; back = 1; } else { *endptr = myend; dk4error_set_simple_error_code(erp, DK4_E_SYNTAX); } } break; default: { *endptr = myend; dk4error_set_simple_error_code(erp, DK4_E_SYNTAX); } break; } } } else { dk4error_set_simple_error_code(erp, DK4_E_MATH_OVERFLOW); } } else { dk4error_set_simple_error_code(erp, DK4_E_MATH_OVERFLOW); } } else { *rp = szr; back = 1; } } else { dk4error_set_simple_error_code(erp, DK4_E_MATH_OVERFLOW); } } return back; } #endif int dk4ma_input_c8_dec_size_t( size_t *rp, const char *src, const char **endptr, int atg, dk4_er_t *erp ) { const char *myend = NULL; dk4_um_t um = (dk4_um_t)0UL; size_t res = 0; size_t factor = 1; size_t nloop = 0; int back = 0; if ((NULL != rp) && (NULL != src)) { if (0 != dk4ma_input_c8_dec_dk4_um_t(&um, src, &myend, 2, erp)) { if (((dk4_um_t)(SIZE_MAX)) >= um) { res = (size_t)um; if (NULL != myend) { back = 1; switch (*myend) { case 'k': case 'K': { nloop = 1; myend++; } break; case 'm': case 'M': { nloop = 2; myend++; } break; case 'g': case 'G': { nloop = 3; myend++; } break; case 't': case 'T': { nloop = 4; myend++; } break; } while (nloop--) { if ((SIZE_MAX / 1024) >= factor) { factor *= 1024; } else { back = 0; dk4error_set_simple_error_code(erp, DK4_E_MATH_OVERFLOW); } } if (0 != back) { if ((SIZE_MAX / factor) >= res) { res *= factor; switch (atg) { case 2: { *rp = res; } break; case 1: { myend = dk4str8_start(myend, NULL); if (NULL != myend) { back = 0; dk4error_set_simple_error_code(erp, DK4_E_SYNTAX); } else { *rp = res; } } break; default: { back = 0; dk4error_set_simple_error_code(erp, DK4_E_SYNTAX); } break; } } else { back = 0; dk4error_set_simple_error_code(erp, DK4_E_MATH_OVERFLOW); } } else { dk4error_set_simple_error_code(erp, DK4_E_MATH_OVERFLOW); } } else { *rp = res; back = 1; } } else { dk4error_set_simple_error_code(erp, DK4_E_MATH_OVERFLOW); } } } else { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); } if (NULL != endptr) { *endptr = myend; } return back; }