git.cworth.org Git - tar/blob - gnu/stdio-write.c

   1 /* -*- buffer-read-only: t -*- vi: set ro: */
   2 /* DO NOT EDIT! GENERATED AUTOMATICALLY! */
   3 /* POSIX compatible FILE stream write function.
   4    Copyright (C) 2008-2010 Free Software Foundation, Inc.
   5    Written by Bruno Haible <bruno@clisp.org>, 2008.
   6
   7    This program is free software: you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include <config.h>
  21
  22 /* Specification.  */
  23 #include <stdio.h>
  24
  25 /* Replace these functions only if module 'sigpipe' is requested.  */
  26 #if GNULIB_SIGPIPE
  27
  28 /* On native Windows platforms, SIGPIPE does not exist.  When write() is
  29    called on a pipe with no readers, WriteFile() fails with error
  30    GetLastError() = ERROR_NO_DATA, and write() in consequence fails with
  31    error EINVAL.  This write() function is at the basis of the function
  32    which flushes the buffer of a FILE stream.  */
  33
  34 # if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
  35
  36 #  include <errno.h>
  37 #  include <signal.h>
  38 #  include <io.h>
  39
  40 #  define WIN32_LEAN_AND_MEAN  /* avoid including junk */
  41 #  include <windows.h>
  42
  43 #  define CALL_WITH_SIGPIPE_EMULATION(RETTYPE, EXPRESSION, FAILED) \
  44   if (ferror (stream))                                                        \
  45     return (EXPRESSION);                                                      \
  46   else                                                                        \
  47     {                                                                         \
  48       RETTYPE ret;                                                            \
  49       SetLastError (0);                                                       \
  50       ret = (EXPRESSION);                                                     \
  51       if (FAILED && GetLastError () == ERROR_NO_DATA && ferror (stream))      \
  52         {                                                                     \
  53           int fd = fileno (stream);                                           \
  54           if (fd >= 0                                                         \
  55               && GetFileType ((HANDLE) _get_osfhandle (fd)) == FILE_TYPE_PIPE)\
  56             {                                                                 \
  57               /* Try to raise signal SIGPIPE.  */                             \
  58               raise (SIGPIPE);                                                \
  59               /* If it is currently blocked or ignored, change errno from     \
  60                  EINVAL to EPIPE.  */                                         \
  61               errno = EPIPE;                                                  \
  62             }                                                                 \
  63         }                                                                     \
  64       return ret;                                                             \
  65     }
  66
  67 #  if !REPLACE_PRINTF_POSIX /* avoid collision with printf.c */
  68 #   if !DEPENDS_ON_LIBINTL /* avoid collision with intl/printf.c */
  69 int
  70 printf (const char *format, ...)
  71 {
  72   int retval;
  73   va_list args;
  74
  75   va_start (args, format);
  76   retval = vfprintf (stdout, format, args);
  77   va_end (args);
  78
  79   return retval;
  80 }
  81 #   endif
  82 #  endif
  83
  84 #  if !REPLACE_FPRINTF_POSIX /* avoid collision with fprintf.c */
  85 int
  86 fprintf (FILE *stream, const char *format, ...)
  87 {
  88   int retval;
  89   va_list args;
  90
  91   va_start (args, format);
  92   retval = vfprintf (stream, format, args);
  93   va_end (args);
  94
  95   return retval;
  96 }
  97 #  endif
  98
  99 #  if !REPLACE_VPRINTF_POSIX /* avoid collision with vprintf.c */
 100 int
 101 vprintf (const char *format, va_list args)
 102 {
 103   return vfprintf (stdout, format, args);
 104 }
 105 #  endif
 106
 107 #  if !REPLACE_VFPRINTF_POSIX /* avoid collision with vfprintf.c */
 108 int
 109 vfprintf (FILE *stream, const char *format, va_list args)
 110 #undef vfprintf
 111 {
 112   CALL_WITH_SIGPIPE_EMULATION (int, vfprintf (stream, format, args), ret == EOF)
 113 }
 114 #  endif
 115
 116 int
 117 putchar (int c)
 118 {
 119   return fputc (c, stdout);
 120 }
 121
 122 int
 123 fputc (int c, FILE *stream)
 124 #undef fputc
 125 {
 126   CALL_WITH_SIGPIPE_EMULATION (int, fputc (c, stream), ret == EOF)
 127 }
 128
 129 int
 130 fputs (const char *string, FILE *stream)
 131 #undef fputs
 132 {
 133   CALL_WITH_SIGPIPE_EMULATION (int, fputs (string, stream), ret == EOF)
 134 }
 135
 136 int
 137 puts (const char *string)
 138 #undef puts
 139 {
 140   FILE *stream = stdout;
 141   CALL_WITH_SIGPIPE_EMULATION (int, puts (string), ret == EOF)
 142 }
 143
 144 size_t
 145 fwrite (const void *ptr, size_t s, size_t n, FILE *stream)
 146 #undef fwrite
 147 {
 148   CALL_WITH_SIGPIPE_EMULATION (size_t, fwrite (ptr, s, n, stream), ret < n)
 149 }
 150
 151 # endif
 152 #endif