fscanf != eof Clang compiler, anomalous behaviour

Question

I'm having an aggravating issue that I can't understand,

void file_count(FILE* stream,int* const num)
{
    int temp;
    while((fscanf(stream,"%d",&temp))!=EOF)
    {
        (*num)++;
    }
}

With this piece of program, I read from a file taking all the numbers inside it, and very time I take a number a counter increases so I can count how many elements are in the file.

In this file there are 6 numbers, but if I run this code the counter skyrockets to 32777... If I compile it with gcc, there's no problem and the counter is 6 as expected. Is this a bug of clang? Is it a feature that I'm not aware of?

The file contains:

22 30 30 21 25 29

The whole code:

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

typedef char* string;
typedef struct student
{
    int flag;
    char name[25];
    char surname[25];
    char dorm[25];
    int* grades;
}
Student;

void check_input(const int argc,const string* const argv);
void check_file(FILE* stream);
void file_count(FILE* stream,int* const num);
void update_student(const string* const infos,Student* const student,const int grades,FILE* stream);
void print_student(FILE* stream,Student const student,const int grades);

int main(int argc, string argv[])
{
    check_input(argc,argv);
    FILE* one,* two;
    string info[]={"David","Malan","Mather"};
    Student student;
    int grades;
    one=fopen(argv[1],"r");
    check_file(one);
    file_count(one,&grades);
    update_student(info,&student,grades,one);
    fclose(one);
    two=fopen(argv[2],"w");
    check_file(two);
    print_student(two,student,grades);
    fclose(two);
    free(student.grades);
    system("cat out");
    return 0;
}

void check_input(const int argc,const string* const argv)
{
    if(argc!=3)
    {
        printf("\x1B[31mError: %s takes two arguments!\x1B[0m\n",argv[0]);
        exit(EXIT_FAILURE);
    }
}

void check_file(FILE* stream)
{
    if(stream==NULL)
    {
        printf("\x1B[31mError:invalid file.\x1B[0m\n");
        exit(EXIT_FAILURE);
    }
}

void file_count(FILE* stream,int* const num)
{
    int temp;
    printf("reading file...\n");
    while((fscanf(stream,"%i",&temp))!=EOF)
    {
        (*num)++;
    }
    printf("\x1B[33mthe value read were %i\x1B[0m\n",*num);
}

void update_student(const string* const infos,Student* const student,const int grades,FILE* stream)
{
    rewind(stream);
    student->grades=malloc(grades*sizeof(int));
    strcpy(student->name,infos[0]);
    strcpy(student->surname,infos[1]);
    strcpy(student->dorm,infos[2]);
    student->flag=0;
    for(int i=0;i<grades;i++)
    {
        fscanf(stream,"%i",&student->grades[i]);
    }
}

void print_student(FILE* stream,Student const student,const int grades)
{
    printf("Writing to file..\n");
    fprintf(stream,"%i %s %s %s ",student.flag,student.name,student.surname,student.dorm);
    for(int i=0;i<grades;i++)
    {
        fprintf(stream,"%i ",student.grades[i]);
    }
    printf("\x1B[32mFile successfully written..\x1B[0m\n");
}

Answer 1

Your code is dangerous, because an incorrect file sends it into an infinite loop.

Once fscanf with %d finds an input that cannot be interpreted as an int, the function returns zero without making any progress on consuming the input. Therefore, the loop never reaches EOF.

You can fix this issue by looping only as long as the input is consumed:

while(fscanf(stream,"%d",&temp) == 1) {
    ...
}

Now you need a way to communicate to the caller if the count is correct or not. You can do that by returning one if EOF is reached, and zero otherwise:

int file_count(FILE* stream,int* const num) {
    int temp, last;
    while((last = fscanf(stream,"%d",&temp)) == 1) {
        (*num)++;
    }
    return last == EOF;
}

I tried with fscaf==1 it still reaches 32777

This happens because you are not initializing grades in the caller. You should define it as int grades = 0, or add *num = 0 before entering the loop in file_count.

Answer 2

The current ISO C standard defines the return value of fscanf() as

The fscanf function returns the value of the macro EOF if an input failure occurs before the first conversion (if any) has completed. Otherwise, the function returns the number of input items assigned, which can be fewer than provided for, or even zero, in the event of an early matching failure.

Verbatim quote from the ISO-C Standard (no public link available, the standard is not public AFAIK)

If there is data to read, but that data cannot be successfully matched, this function will return 0. It will only return EOF (which is typically -1) if there is no data to read because the stream you are reading from is in EOF state or had another read error.

So if you had a file like that:

23 a 57

The loop will never terminate. On first scan it will read 23 and return 1 (one value matched). On next call it will return 0, as a cannot be matched to an integer. Yet, it also won't move the file pointer beyond a. So on next call, it tries to match a again and it will fail again. This continues endlessly.