_CODE_ACCESS long strtol(const char *st, char **endptr, int base)
{
register unsigned long result = 0;
register unsigned int uns_base;
register char cp;
register const char *fst = st;
int digits = 0;
unsigned long sign = 0;
unsigned long max_prev_result;
unsigned long max_curr_addval;
unsigned long range_limit;

while (_isspace(*fst)) ++fst; /* SKIP WHITE SPACE */

if ((cp = *fst) == '-')
{
sign = 1;
cp = *++fst;
}
else if (cp == '+') cp = *++fst;

if (base > 36) base = 0;

/*-------------------------------------------------------------------*/
/* DETERMINE BASE IF ZERO BASE ASKED FOR. */
/*-------------------------------------------------------------------*/
switch (base)
{
case 0 : if (cp != '0') base = 10;
else if ((cp = *++fst) == 'x' || cp == 'X')
if (_isxdigit(fst[1])) { base = 16; cp = *++fst; }
else { base = 10; cp = *--fst; }
else
{
base = 8;
if (cp < '0' || cp > '7') cp = *--fst;
}
break;

case 16 : if (cp == '0' && ((fst[1] == 'x') || (fst[1] == 'X')) &&
_isxdigit(fst[2]))
cp = *(fst += 2);
}

/*-------------------------------------------------------------------*/
/* DETERMINE VALUES NEEDED TO DETECT RANGE ERROR. THE MAX UNSIGNED */
/* VALUE THAT IS IN RANGE IS BASED ON THE SIGN OF THE INPUT STRING: */
/* sign == 1 - RESULT WILL BE NEGATIVE, SO MUST BE <= LONG_MAX+1 */
/* sign == 0 - RESULT WILL BE POSITIVE, SO MUST BE <= LONG_MAX */
/* SO range_limit is LONG_MAX + sign. */
/* */
/* ALSO NEED max_prev_result AND max_curr_addval WHERE: */
/* max_prev_result * uns_base + max_curr_addval == range_limit */
/* */
/* THIS ALLOWS US TO TEST FOR RANGE ERROR BEFORE WE COMPUTE THE NEXT */
/* RESULT. WE HAVE TWO CASES: */
/* - PREVIOUS result IS GREATER THAN max_prev_result, SO NEXT */
/* RESULT MUST BE OUT OF RANGE. */
/* - PREVIOUS result IS EQUAL TO max_prev_result, SO NEXT RESULT */
/* IS OUT OF RANGE IF addval > max_curr_addval. */
/*-------------------------------------------------------------------*/
uns_base = (unsigned int) base;
range_limit = (unsigned long)LONG_MAX + sign;
max_prev_result = range_limit / uns_base;
max_curr_addval = range_limit % uns_base;

/*-------------------------------------------------------------------*/
/* CONVERT THE NUMBER USING THE SPECIFIED BASE. */
/*-------------------------------------------------------------------*/
for (;; cp = *++fst)
{
register unsigned long addval;

if (!((_isdigit(cp) && (addval = cp - '0') < uns_base) ||
(_isupper(cp) && (addval = cp - 'A' + 10) < uns_base) ||
(_islower(cp) && (addval = cp - 'a' + 10) < uns_base))) break;

/*--------------------------------------------------------------*/
/* CHECK OVERFLOW STATUS BEFORE COMPUTATION. */
/* result CONTAINS THE RESULT OF THE PREVIOUS COMPUTATION */
/*--------------------------------------------------------------*/
if (result > max_prev_result ||
(result == max_prev_result && addval > max_curr_addval))
{
/* SET ERRNO */
errno = ERANGE;
if (endptr) *endptr = (char *)st;
return sign ? LONG_MIN : LONG_MAX;
}

/*--------------------------------------------------------------*/
/* COMPUTE NEXT RESULT. */
/*--------------------------------------------------------------*/
result = result * uns_base + addval;

digits++;
}

/*-------------------------------------------------------------------*/
/* MARK THE END OF THE CONVERTED INPUT. NEGATE THE RESULT IF A */
/* MINUS SIGN WAS SEEN. */
/*-------------------------------------------------------------------*/
if (endptr) *endptr = (char *)(digits ? fst : st);
if (sign)
return (long)-result;

return (long)result;
}

double toDouble(const char * str, bool * ok);

const char * str = "0.252";
bool ok;
double var = toDouble(str, &ok);

unsigned char str2int32(int32_t *result, char *s); // returns 0 if error or  number of symbols handled
//....usage
int32_t a,b,c,d;
char source[]="123, 7689540";
char s2[]="123,7689540";

if(str2int32(&a,source)&&str2int32(&b,&source[5])
{
  c = a+b;
}

if(str2int32(&a,&s2[str2int32(&b,s2)]))
{
  d = a+b;
}

assert(c==d);