Question

I have read through the C11 standard, section 7.21 where <stdio.h> is described. The standard first describes streams as:

7.21.2.2:

A text stream is an ordered sequence of characters …

7.21.2.3:

A binary stream is an ordered sequence of characters …

Which doesn’t specify the type of the stream characters (since this depends on orientation). It later says:

7.21.3.12:

… The byte output functions write characters to the stream as if by successive calls to the fputc function.

From fputc (7.21.7.3.2):

The fputc function writes the character specified by c (converted to an unsigned char) to the output stream pointed to by stream …

Which indicates the int c argument of fputc is converted to an unsigned char before being written to the stream. A similar note is given for fgetc:

7.21.7.1.2:

the fgetc function obtains that character as an unsigned char converted to an int

and ungetc, fread and fwrite.

Now this all hints that internally, a byte oriented stream is represented by unsigned chars.

However, looking at the internals of the Linux kernel, it seems like files are considered to be streams of char. One reason I am saying this is that the file_operations read and write callbacks get char __user * and const char __user * respectively.

In the implementation of glibc, FILE is a typedef of struct _IO_FILE which is defined in libio/libio.h. In this struct also, all read and write pointers are char *.

In C++, the basic_ostream::write function takes const char * as input and similarly basic_istream::read (but I’m not interested in C++ in this question).

My question is, do the quotes above imply that FILE streams should be threated as streams of unsigned char? If so, why does the glibc and the Linux kernel implement them with char *? If not, why does the standard insist on converting the characters to unsigned char?

Answer 1

It doesn’t really matter. The standard use unsigned char at some chosen place because it allows precise formulation at those places:

• fgetc is specified to return a unsigned char converted to an int so that one knows that the result is positive or null excepted when it is EOF (and thus there is no confusion possible between EOF and a valid char, confusion which is cause of bugs when one store directly the result of fgetc in a char without checking for EOF beforehand).

• fputc is specified to take an int and convert it to an unsigned char because this conversion is well specified. If you aren’t careful, formulation not using unsigned char could make UB a sequence like

  int c = fgetc(stdin);
  if (c != EOF)
      fputc(c, stdout);
  

with signed char for negative chars.