check_space: buffer_space = (stream->__bufsize - (stream->__bufp - stream->__buffer)); if (buffer_space == 0) {  if (__flshfp (stream, *p++) == EOF) goto done; ++written; --to_write; goto check_space; } } }
check_space: buffer_space = (stream->__bufsize - (stream->__bufp - stream->__buffer)); if (buffer_space == 0) {  if (__flshfp (stream, *p++) == EOF) goto done; ++written; --to_write; goto check_space; } } }   if (newlinep) fflush (stream); }
DEFUN(fwrite, (ptr, size, nmemb, stream),      CONST PTR ptr AND size_t size AND      size_t nmemb AND register FILE *stream){  register CONST unsigned char *p = (CONST unsigned char *) ptr;  register size_t to_write = size * nmemb;  register size_t written = 0;  int newlinep;  size_t buffer_space;  int default_func;  if (!__validfp (stream) || !stream->__mode.__write)    {      errno = EINVAL;      return 0;    }  if (ferror (stream))    return 0;  if (p == NULL || to_write == 0)    return 0;  if (!stream->__seen || stream->__put_limit == stream->__buffer)    {      /* This stream has never been seen before.	 Calling __flshfp will give it a buffer	 and I/O functions if it needs them.  */      if (__flshfp (stream, *p++) == EOF)	return 0;      if (--to_write == 0)	return 1;      else	++written;    }  default_func    = stream->__room_funcs.__output == __default_room_functions.__output;  {    int save = errno;    if (__stdio_check_offset (stream) == EOF && errno != ESPIPE)      {	stream->__error = 1;	goto done;      }    errno = save;  }  if (stream->__buffer == NULL && default_func &&      stream->__offset == stream->__target)  write_through:    /* This is an unbuffered stream using the standard output       buffer-flushing function, so we just do a straight write.  */    {      int count = (stream->__io_funcs.__write == NULL ? to_write :		   (*stream->__io_funcs.__write) (stream->__cookie,						  (CONST char *) p,						  to_write));      if (count > 0)	{	  written += count;	  if (stream->__offset != -1)	    {	      stream->__offset += count;	      stream->__target = stream->__offset;	    }	  to_write -= count;	  p += count;	}      else	stream->__error = 1;      goto done;    }  /* We ignore the end pointer here since we want to find out how much space     is really in the buffer, even for a line-buffered stream.  */  buffer_space = stream->__bufsize - (stream->__bufp - stream->__buffer);  newlinep = (stream->__linebuf &&	      memchr ((CONST PTR) p, '\n', to_write) != NULL);  if (newlinep && stream->__bufp == stream->__buffer &&      stream->__offset == stream->__target)    /* The buffer's empty, and we want to write our data       out soon anyway, so just write it straight out.  */    goto write_through;  if (stream->__bufsize == 0 && !default_func)    {      /* No buffer, and a special function.	 We can't do much better than putc.  */      while (to_write-- > 0)	{	  if (__flshfp (stream, *p++) == EOF)	    break;	  else	    ++written;	}    }  else if (!default_func || buffer_space >= to_write)  fill_buffer:    /* There is enough room in the buffer for everything we       want to write or the user has specified his own output       buffer-flushing/expanding function.  */    while (to_write > 0)      {	register size_t n = to_write;	if (n > buffer_space)	  n = buffer_space;	buffer_space -= n;	written += n;	to_write -= n;	if (n < 20)	  while (n-- > 0)	    *stream->__bufp++ = *p++;	else	  {	    memcpy ((PTR) stream->__bufp, (PTR) p, n);	    stream->__bufp += n;	    p += n;	  }	if (buffer_space == 0 || (to_write == 0 && newlinep))	  {	    /* We've filled the buffer, so flush it.  */	    if (fflush (stream) == EOF)	      break;	    /* Reset our record of the space available in the buffer,	       since we have just flushed it.  */	  check_space:	    buffer_space = (stream->__bufsize -			    (stream->__bufp - stream->__buffer));	    if (buffer_space == 0)	      {		/* With a custom output-room function, flushing might		   not create any buffer space.  Try writing a single		   character to create the space.  */		if (__flshfp (stream, *p++) == EOF)		  goto done;		++written;		--to_write;		goto check_space;	      }	  }      }  else    {      /* It won't all fit in the buffer.  */      if (stream->__bufp != stream->__buffer)	{	  /* There are characters in the buffer.  Flush them.  */	  if (__flshfp (stream, EOF) == EOF)	    goto done;	}      /* The buffer has been flushed.	 Now either fill it or write directly.  */      buffer_space = stream->__bufsize - (stream->__bufp - stream->__buffer);      if (stream->__offset == stream->__target &&	  (buffer_space < to_write || newlinep))	/* What we have to write is bigger than the buffer,	   or it contains a newline and we're line-buffered,	   so write it out.  */	goto write_through;      else	/* It will fit in the buffer.  */	goto fill_buffer;    } done:;  return (size_t) written / size;}