32bit C program no longer converting char to int on 64 bit OS Linux

Question

a simple question:

this function worked perfectly on my 32 Bit Linux then I got a 64 Bit Linux and now it is no longer working. I've narrowed it down to this function in converting the data from Char to Int. it no longer does this. this is where I am stuck at right now. all this functions is doing is taking a format like this 100x100 then chopping out the x and keeping the two numbers on both sides then changing them into Int's.

Using atoi is now returning junk now that I am running it on this 64bit Linux. what function call do I have to use that will make it work again only on both 32 and 64 bit Linux programs now?

int findX(char *whereisX, int *rW, int *rH)
{
printf("entering findx dia is %s\n\n", whereisX);
char *tok1, *tok2, *saveptr;
char x = (int) malloc(sizeof(whereisX));

char str1[x];
int bW, bH;

strcpy(str1, whereisX);

tok1 = strtok_r(whereisX, "x", &saveptr);
tok2 = strtok_r(NULL, "x", &saveptr);

if ( tok2 == NULL)
{   printf("found return 1\n");
    return 1;
}
 else
    { printf("returning 0\n");
        tok1 = strtok_r(str1, "x", &saveptr);
        tok2 = strtok_r(NULL, "x", &saveptr);

        printf("tok1 is .. %s and tok2 is %s\n", tok1 , tok2);

    // here is where I am converting it from Char to Int
    // using atoi now gives me back junk 

     // bW = atoi(tok1);
     //    bH = atoi(tok2);


    bW = atoll(tok1);
    bH = atoll(tok2);
        printf("bW is %c and bH is %c\n", bW, bH);
       // printf("string -- bW is %s and bH is %s\n", bW,bH);
    /* assigning the results to the output */
       *rW = bW;
       *rH = bH;
    printf("rW is %s  rH is %s\n", rW  , rH); 
       return 0;
     }
} //end findX

output is

tok1 is .. 200 and tok2 is 100
// after converting from char to int using atoi
bW is � and bH is d
rW is �  rH is d

Answer 1

These lines which you use to assign memory to copy the passed string are nonsense.

char x = (int) malloc(sizeof(whereisX));    // does not give the string length
char str1[x];                               // does not allow for terminator
int bW, bH;
strcpy(str1, whereisX);

Would be better as

char str1[1+strlen(whereisX)];
strcpy(str1, whereisX);

It's a wonder that your earlier version worked at all!

EDIT

Lets walk through it:

char x = (int) malloc(sizeof(whereisX));

The malloc allocates memory for a char* pointer - previously 4 bytes, now 8.

The (int)malloc converts the address of the memory allocated to an integer.

The char x = then stores the integer in 8 bits. This has nothing to do with the length of the string you will copy.

Next char str1[x]; assigns an array of a size totally unrelated to the length of string you will copy. Even if you did have the right length, it need to be one element longer to take the nul terminator. If it worked before, is pure luck that you ended up with a long enough array.

But switching to a different compiler has shown up this bug.

So rather than say I haven't answered your question, please correct your mistake and see if it fixes the problem. Maybe it will, maybe not: I haven't looked past line 3 to see if there are any other howlers.

Answer 2

The correct version of your code is:

int findX(char *whereisX, int *rW, int *rH)
{
    printf("entering findx dia is %s\n\n", whereisX);
    char *tok1, *tok2, *saveptr;

    char *str1 = (char*)malloc(1 + strlen(whereisX));
    int bW, bH;

    strcpy(str1, whereisX);

    tok1 = strtok_k(whereisX, "x", &saveptr);
    tok2 = strtok_k(NULL, "x", &saveptr);

    if (tok2 == NULL)
    {
        printf("found return 1\n");
        free(str1);
        return 1;
    }
    else
    {
        printf("returning 0\n");
        tok1 = strtok_k(str1, "x", &saveptr);
        tok2 = strtok_k(NULL, "x", &saveptr);

        printf("tok1 is .. %s and tok2 is %s\n", tok1, tok2);

        bW = atoi(tok1);
        bH = atoi(tok2);

        printf("bW is %d and bH is %d\n", bW, bH);
        /* assigning the results to the output */
        *rW = bW;
        *rH = bH;

        printf("rW is %d  rH is %d\n", *rW, *rH);
        printf("tok1 is %s  tok2 is %s\n", tok1, tok2);

        free(str1);
        return 0;
    }
} //end findX

Note the differences: you were using malloc in the totally wrong way, you were using printf format identifiers in the totally wrong way, you weren't freeing the allocated string.

I'll add that you are doing the strtok_r twice (once outside the if and once inside the if). The two will return the same data, because str1 is a copy of whereisX

The code then can be simplified to:

int findX(char *whereisX, int *rW, int *rH)
{
    printf("entering findx dia is %s\n\n", whereisX);
    char *tok1, *tok2, *saveptr;

    int bW, bH;

    tok1 = strtok_k(whereisX, "x", &saveptr);
    tok2 = strtok_k(NULL, "x", &saveptr);

    if (tok2 == NULL)
    {
        printf("found return 1\n");
        return 1;
    }
    else
    {
        printf("returning 0\n");

        printf("tok1 is .. %s and tok2 is %s\n", tok1, tok2);

        bW = atoi(tok1);
        bH = atoi(tok2);
        printf("bW is %d and bH is %d\n", bW, bH);
        // printf("string -- bW is %s and bH is %s\n", bW,bH);
        /* assigning the results to the output */
        *rW = bW;
        *rH = bH;
        printf("rW is %d  rH is %d\n", *rW, *rH);
        printf("tok1 is %s  tok2 is %s\n", tok1, tok2);
        return 0;
    }
} //end findX

The fact that random programs written in C sometimes run returning somethings that seems to be correct doesn't mean they are correct. It only means that you got lucky. This luck doesn't ever last.