(Almost-)POSIX-compliant operating systems and Windows are known to distinguish between 'binary mode' and 'text mode' file I/O. While the former mode doesn't transform any data between the actual file or stream and the application, the latter 'translates' the contents to some standard format in a platform-specific manner: line endings are transparently translated to
'\n' in C, and some platforms (CP/M, DOS and Windows) cut off a file when a byte with value
0x1A is found.
These transformations seem a little useless to me.
People share files between computers with different operating systems. Text mode would cause some data to be handled differently across some platforms, so when this matters, one would probably use binary mode instead.
As an example: while Windows uses the sequence
CR LF to end a line in text mode, UNIX text mode will not treat
CR as part of the line ending sequence. Applications would have to filter that noise themselves. Older Mac versions only use
CR in text mode as line endings, so neither UNIX nor Windows would understand its files. If this matters, a portable application would probably implement the parsing by itself instead of using text mode.
Implementing newline interpretation in the parser might also remove some overhead of using text mode, as buffers would need to be rewritten (and possibly resized) before returning to the application, while this may be less efficient than when it would happen in the application instead.
So, my question is: is there any good reason to still rely on the host OS to translate line endings and file truncation?