Thread: writing to stdin !

I don't think writing to stdin is defined. Is it?

stdin is "opened/created" with something akin to

Code:

 stdin = fopen("console", "r");

.

The fact that stdin is part of the standard IO and predefined by the runtime system, rather than a user-created file doesn't change the way it's being used or what that file does.

You can't "write" to a file that is opened for "read only", no matter which file it is. What happens if you do that is entirely system dependant and definitely in the undefined behaviour realm - for instance, little green men may turn up in the office cubicle where you sit, or the computer may sprout wings and fly away [like drinking Red Bull ?]. But more likely, it will just not do anything - just discard the data and possibly set errno - or that it crashes because it attempts to access some file-buffer portion that isn't valid.

--
Mats

>Can anyone explain why please.
The exact "why" depends on your implementation. The abstract "why" is that the fprintf isn't defined for input streams, so what you're trying to do is undefined. But for completeness, here's the "why" for one possible implementation[1]. Let's say that the printing of characters in fprintf boils down to this little guy:

Code:

#define _put(c,out,n) ( ++n, fputc ( c, out ) )

Rather anticlimactic, I know, but fprintf still does a lot of work. Taking a look at fputc, we can see what's going on in that particular logic:

Code:

int fputc ( int c, FILE *out )
{
  /* The stream must be open and ready for writing */
  if ( !( out->_flag & _OPEN )
    || out->_flag & _READ )
  {
    return EOF;
  }

  /* Reset the stream to write mode */
  out->_flag &= ~_READ;
  out->_flag |= _WRITE;

  _deque_pushf ( out->_buf, (char)c );

  if ( ( out->_flag & _LBF && c == '\n' ) /* Line buffered; flush on '\n' */
    || out->_flag & _NBF                  /* Non-buffered; always flush */
    || _deque_full ( out->_buf ) )        /* Full buffer; always flush */
  {
    if ( _intern_flush ( out ) != 0 )
      return EOF;
  }

  return c;
}

The exact representation of the _flag member isn't necessary. How it's used is relatively simple. Likewise, _deque_pushf, _deque_full, and _intern_flush aren't relevant because it's the first if statement that we're interested in.

This test is a likely implementation. It checks to make sure that the stream is initialized, and it also checks to see if the stream is oriented properly. stdout would be open and in write mode, but stdin would be open and in read mode, which fails the test and causes fputc to return EOF. I'd wager a guess that "undefined behavior" in the case of the following program will be to print the same value twice for any reasonably intelligent implementation:

Code:

#include <stdio.h>

int main ( void )
{
  printf ( "%d\n", EOF );
  printf ( "%d\n", fputc ( 'a', stdin ) );
  return 0;
}

So the "why" is that your implementation was probably looking out for that kind of code. Because allowing it would trash at least one buffer internally and place the standard streams into an unpredictable state, it simply disallowed the operation.

[1] It's probably overkill to pull out my example stream implementation, but I will anyway.

Prelude, I'm just a bit curious as to why the following line is necessary in your code:

Code:

  out->_flag &= ~_READ;

Since the previous code-segment has checked if this out->_flag & _READ and decided it's not set.

Obviously no harm in doing it, but it seems unnecessary.

--
Mats

>I'm just a bit curious as to why the following line is necessary in your code
Clarity. I wanted it to be absolutely obvious that _READ and _WRITE are mutually dependent modes.

Originally Posted by Prelude

>I'm just a bit curious as to why the following line is necessary in your code
Clarity. I wanted it to be absolutely obvious that _READ and _WRITE are mutually dependent modes.

Fair 'nuff.

--
Mats