IF statement fails to check a correct value

Question

I have a function that translates a string coordinate to an int number from 0-9. Now the function seems to fail to get the string A10(for example) and translate it to 0,9. Maybe someone can tell me why?

Point TranslateCoordinate(char* c){
        Point newpoint;
        newpoint=malloc(sizeof(Point));//this is beacuse its an ADT
        int row=c[0];
        int column;
        newpoint->x=row-'A';
        if(c[1]== '1' && c[2]== '0'){
            newpoint->y=9;
            return newpoint;
        }
        column=c[1];
        newpoint->y=column-'1';
        return newpoint;
}

I should note that the values of the string range from 1 to 10 and from A to J. Also this is the call of the function from main; it gets a string from a file and assigns it to a struct called submarine.

while(fgets(buffer,100,fptr))
{
    if(isalpha(buffer[0]))
    {
        token=strtok(buffer,"-");
        start=TranslateCoordinate(token);
        token=strtok(NULL,"\n");
        end=TranslateCoordinate(token);
        s=Makesub(start,end,9);
        P1list=Add_to_list(s,P1list);
    }
}

The struct itself as written in the source:

struct Point_s
{
    int x;
    int y;
};

The typedef that is written in the header:

typedef struct Point_s* Point;

Answer 1

    Point newpoint;
    newpoint=malloc(sizeof(Point));

This cannot possibly be correct.

Point seems to be typedefed to be a pointer to some struct. This is by itself bad style that is going to give you problems. If you want to keep this anyway, the simplest correct calling sequence would be

    newpoint = malloc(sizeof(*newpoint));

It is also in my opinion a good all-around style even without pointer typedefs, so I would recommend using it always.

    something = malloc(sizeof(*something));

Easy to remember and doesn't need to be updated if you ever change the type of something.

I would recommend ditching that typedef and replacing it with explicit pointer notation:

typedef struct point
{
        ...
} Point;

Point* TranslateCoordinate(char* c){
    Point* newpoint;
    newpoint = malloc(sizeof(*newpoint));
    ...

The code as it stands now has undefined behaviour if sizeof(Point) is less that sizeof(*newpoint), so absolutely anything can happen.

Answer 2

Well, it does happen to work:

#include <stdlib.h>
#include <stdio.h>

typedef struct {
    int x, y;
} *Point;

Point TranslateCoordinate(char* c){
        Point newpoint;
        newpoint=malloc(sizeof(Point));
        int row=c[0];
        int column;
        newpoint->x=row-'A';
        if(c[1]== '1' && c[2]== '0'){
            newpoint->y=9;
            return newpoint;
        }
        column=c[1];
        newpoint->y=column-'1';
        return newpoint;
}

int main (int argc, char *argv[]) {
    Point p;

    p = TranslateCoordinate("A10");
    printf("%d, %d\n", p->x, p->y);
    return 0;
}

…but only when sizeof(Point) == sizeof(void*) == 2 * sizeof(int) == sizeof(*newpoint). If that relation does not hold, anything may happen.

Thus, to avoid undefined behavior, allocate the point like this:

newpoint=malloc(sizeof(*newpoint));