pintos-os.org Git - pspp/blob - lib/stdio-write.c

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