if (isdigit(*p)||isspace(*p))
 {
      check= atoi(p);
    return check;
  }

Probably simpler is just looping over the string, skipping white space
and calculating the result manually, perhaps like this (take care,
code is untested):

int read( void )
{
    char message[ 90 ];
    char *cur;
    sign = 1;
    int val = 0;

    fgets( message, 90, stdin );

    /* Skip leading white space part of string and catch minus sign */

    for ( cur = message; *cur != '\0' && ! isdigit( *cur ) ; cur++ )
    {
        if ( *cur == '-' )
        {
            sign = -1;
            break;
        }

        if ( ! isspace( *cur ) )              /* invalid characer ? */
            exit( EXIT_FAILURE );
    }

    /* Loop over rest of string, calculating the resulting number and
       skipping white space */

    for ( ; *cur != '\0'; cur++ )
        if ( isdigit( *cur ) )
        {
            val = val * 10 + ( *cur - '0' );
            if ( val < 0 )                     /* integer overflow ? */
                exit( EXIT_FAILURE );
        }
        else if ( ! isspace( *cur ) )          /* invalid characer ? */
            exit( EXIT_FAILURE );

    return sign * val;

#include <stdlib.h>
#include <limits.h>
#include <errno.h>
#include <ctype.h>
/*
 * parse_ints: splits "line" into "nums", returning the count.
 * "nums" is a dynamically allocated int *, and must be freed
 * by the caller if parse_ints returns a number greater than
 * zero.
 * Returns -1 on error.
 */
int parse_ints (char *line, int **nums) {
    int count = 0;
    int errors = 0;
    long number;
    int *array = NULL, *iptr;
    char *cptr, *endptr;

    cptr = line;
    while (cptr != NULL && *cptr != '\0' && !errors) {
         errno = 0;
         number = strtol (cptr, &endptr, 10);
         if (cptr == endptr || errno == ERANGE) errors++;
         if (number < INT_MIN || number > INT_MAX) errors++;
         if (!errors) {
             iptr = realloc (array, sizeof *iptr * (count + 1));
             if (iptr != NULL) {
                 array = iptr;
                 array[count++] = (int) number;
             }
             else {
                errors++;
             }
         }
         cptr = endptr;
         while (isspace(*cptr))
             cptr++;
    }
    if (errors) {
        free (array);
        count = -1;
    }
    else {
        *nums = array;
    }
    return count;

I now included the flag ('found_digit') to figure out if there were any
digits at all in the input, see below. And, since you were writing about
integers you obviously have to take into account negative numbers and
thus minus signs. And, finally, since you were only testing for white-
space characters I assume that other non-digits are to be treated as an
error in the input.

The check if 'val' is negative is there to find out if the number got
larger than the maximum value you can represent with an integer value.
In this case you get a wrap-around, i.e. too large a number gets truncated
and you end up with a *negative* number.

                                          Regards, Jens

PS: Please stop top-posting: put your comments etc. below what you
    quote of other peoples messages. This way it's much easier to
    follow what you refer to. And please also remove everything not
    strictly necessary from what you quote, no-one likes to have to
    browse through hundreds of lines of useless text just to find the
    one interesting point.

----------------------8<---------------------------------------------------
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <limits.h>

int read_int_v1( const char *message );
int read_int_v2( const char *message );

int main( void )
{
    char message[ 90 ];

    if ( fgets( message, 90, stdin ) == NULL )
    {
        fprintf( stderr, "No input found\n" );
        exit( EXIT_FAILURE );
    }

    printf( "Version 1: You entered %d\n", read_int_v1( message ) );
    printf( "Version 2: You entered %d\n", read_int_v2( message ) );
    return EXIT_SUCCESS;

    /* Skip leading white space at start of string and catch minus sign */

    for ( cur = message; *cur != '\0' && ! isdigit( *cur ) ; cur++ )
    {
        if ( *cur == '-' )
        {
            sign = -1;
            cur++;
            break;
        }

        if ( ! isspace( *cur ) )              /* invalid characer ? */
        {
            fprintf( stderr, "Invalid character: '%c'\n", *cur );
            exit( EXIT_FAILURE );
        }
    }

    /* Loop over rest of string, calculating the resulting number and
       skipping white space */

    for ( ; *cur != '\0'; cur++ )
        if ( isdigit( *cur ) )
        {
            found_digit = 1;
            val = val * 10 + ( *cur - '0' );
            if ( val < 0 )                     /* integer overflow ? */
            {
                fprintf( stderr, "Integer overflow\n" );
                exit( EXIT_FAILURE );
            }
        }
        else if ( ! isspace( *cur ) )          /* invalid characer ? */
        {
            fprintf( stderr, "Invalid character: '%c'\n", *cur );
            exit( EXIT_FAILURE );
        }

    /* Check if there were any digits at all in the input */

    if ( ! found_digit )
    {
        fprintf( stderr, "No digits found in input\n" );
        exit( EXIT_FAILURE );
    }

    return sign * val;

    /* Make sure to only modify a copy of the input string, so the function
       can also be applied to strings we're not allowed to modify. */

    strcpy( str, message );

    /* Start off by looking for the first character that's either a digit
       or a minus sign (bail out when there's an error in the input). */

    for ( p0 = str; *p0 != '\0' && isspace( *p0 ) && *p0 != '-'; p0++ )
          /* empty */ ;

    if ( *p0 == '\0' )
    {
        fprintf( stderr, "No numbers found in input\n" );
        exit( EXIT_FAILURE );
    }

    if ( ! isdigit( *p0 ) && *p0 != '-' )
    {
        fprintf( stderr, "Invalid character: '%c'\n", *p0 );
        exit( EXIT_FAILURE );
    }

    /* Also calculate a pointer to the very end of the input string, i.e.
       the trailing '\0'. */

    for ( p_end = p0 + 1; *p_end != '\0'; p_end++ )
        /* empty */ ;

    /* p0 points now to the first digit or a minus sign. Now, in the remaining
       string, look for sets of white-space characters followed by a digit. In
       this case we simply copy everything following this region to the place
       where the first white-space character was found. */

    for ( p1 = p0 + 1; *p1 != '\0'; p1++ )
    {
        if ( isdigit( *p1 ) )
             continue;

        if ( ! isspace( *p1 ) )
        {
            fprintf( stderr, "Invalid character: '%c'\n", *p1 );
            exit( EXIT_FAILURE );
        }

        /* p1 now points to a white-space character. Loop over the following
           characters, using pointer p2, until a digit is found (or an error
           in the input is detected). */

        for ( p2 = p1 + 1; p2 != '\0' && isspace( *p2 ); p2++ )
            /* empty */ ;

        if ( *p2 == '\0' )       /* string ended with white-space ? */
        {
            *p1 = '\0';
            break;
        }

        if ( ! isdigit( *p2 ) )
        {
            fprintf( stderr, "Invalid character: '%c'\n", *p2 );
            exit( EXIT_FAILURE );
        }

        /* p2 now points to a digit and we move everything from p2 to the
           end of the string (including the trailing '\0') to where p1
           points. Since the string is now shorter we also have to correct
           the end pointer, p_end. */

        memmove( p1, p2, p_end - p2 + 1 );
        p_end -= p2 - p1;
    }

    /* Now check that we didn't got just a minus sign and nothing else. */

    if ( *p0 == '-' && *( p0 + 1 ) == '\0' )
    {
        fprintf( stderr, "Only found a minus sign\n" );
        exit( EXIT_FAILURE );
    }

    /* Before we can return the result of applying atoi() to p0 we must
       check that the number we got isn't too large for an integer. We
       do this by comparing the cleaned-up string with the one we get when
       we print the return value of atoi() into a string. If both are
       identical everything's ok, otherwise the original number was too
       large for an integer. */

Calling function:

    int *nums = NULL;
    int count = parse_ints (instr, &nums);
    ...

Taking the address of a variable yields a pointer to that variable. Now,
parse_ints can change its view of "nums" all it wants and the caller will
never see the changes.  However, if parse_ints changes "*nums", then
the caller will see the changes.

The caller originally has:

     nums -> NULL

The caller calls parse_ints with "&nums" and parse_ints sees:

     nums -> <some address> -> NULL (same NULL from caller).

Then parse_ints updates *nums:

     int * array = ... ;  /* create the array somehow ... */    
     *nums = array;       /* Sets the callers "nums" to array */

Well, that probably didn't make any sense... Sorry ;-(

Note: The above free() call is only called if an error occurred.  Otherwise,
the function assumes that the caller will free the memory when they're done
with it.  For instance:

    if ( val > ( INT_MAX - ( *p - '0' ) ) / 10 )
        return EXIT_FAILURE;
    val = val * 10 + ( *p - '0' );

But this more or less requires to do the calculation twice. (And to make
it work cleanly for both positive and negative integers I would need two
different loops because INT_MAX isn't necessarily equal to -INT_MIN and
even writing -INT_MIN might lead to trouble if INT_MAX < -INT_MIN). Any-
one with an idea for a better and more elegant method?

Yes, INT_MIN == -INT_MAX-1 (in 2sC) is a problem.
I usually punt by converting to the string to _unsigned_ int
and then worrying about the sign (although it is also
theoretically possible that UINT_MAX == INT_MAX)
or actually to _unsigned long_ and then worry about
narrowing _or_ limiting to a range _and/or_ sign.

 - Calculate the number that, if there is another valid digit, results
   in potential overflow.  If the number is nonnegative and INT_MAX is
   32767 and we are working in base ten, this is 3276.  If the number
   is negative and INT_MIN is -32768 (and we are still working in base
   ten), the number is again 3276, although this time -3276.  Call
   this the "cutoff" number -- inputs that exceed the cutoff definitely
   overflow, while inputs that exactly equal the cutoff may be OK.

 - Next, calculate the digit beyond which overflow occurs.  For
   our two cases (nonnegative and negative), these are 7 and 8
   respectively.  Call this the limit for "cutoff numbers", i.e.,
   an input of 3276 with a following digit of 7 (for positive)
   or 8 (for negative) is OK, but one with anything greater than
   7 (respectively 8) is not.

Note that these numbers are simply INT_MAX / 10 and INT_MAX % 10
(and similar for INT_MIN, although in C89 the rounding direction
is not specified in advance).

Now we have an easy test for "will overflow" (but watch out for
sign inversion for negative numbers):

    if (there is another valid digit) {
        if (val > cutoff ||                     /* e.g., val > 3276 */
            (val == cutoff && digit > cutlim))  /* e.g., 3276 but digit is 9 */
            ... handle would-overflow error ...
        else
            val = val * 10 + digit;
    }