support/stdio.c

   1 /*
   2  * <stdio.h> wrapper functions.
   3  *
   4  * Authors:
   5  *   Jonathan Pryor (jonpryor@vt.edu)
   6  *
   7  * Copyright (C) 2004-2006 Jonathan Pryor
   8  */
   9
  10 #include <stdarg.h>
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13
  14 #include "map.h"
  15 #include "mph.h"
  16
  17 G_BEGIN_DECLS
  18
  19 #ifndef HOST_WIN32
  20 gint32
  21 Mono_Posix_Syscall_L_ctermid (void)
  22 {
  23         return L_ctermid;
  24 }
  25
  26 gint32
  27 Mono_Posix_Syscall_L_cuserid (void)
  28 {
  29 #if defined(__APPLE__) || defined (__OpenBSD__)
  30         return -1;
  31 #else
  32         return L_cuserid;
  33 #endif
  34 }
  35 #endif /* ndef HOST_WIN32 */
  36
  37 mph_size_t
  38 Mono_Posix_Stdlib_fread (unsigned char *ptr, mph_size_t size, mph_size_t nmemb, void *stream)
  39 {
  40         mph_return_if_size_t_overflow (size);
  41         mph_return_if_size_t_overflow (nmemb);
  42
  43         return fread (ptr, (size_t) size, (size_t) nmemb, (FILE*) stream);
  44 }
  45
  46 mph_size_t
  47 Mono_Posix_Stdlib_fwrite (unsigned char *ptr, mph_size_t size, mph_size_t nmemb, void *stream)
  48 {
  49         mph_return_if_size_t_overflow (size);
  50         mph_return_if_size_t_overflow (nmemb);
  51
  52         return fwrite (ptr, (size_t) size, (size_t) nmemb, (FILE*) stream);
  53 }
  54
  55 #ifdef HAVE_VSNPRINTF
  56 gint32
  57 Mono_Posix_Stdlib_snprintf (char *s, mph_size_t n, char *format, ...);
  58 gint32
  59 Mono_Posix_Stdlib_snprintf (char *s, mph_size_t n, char *format, ...)
  60 {
  61         va_list ap;
  62         gint32 r;
  63         mph_return_if_size_t_overflow (n);
  64
  65         va_start (ap, format);
  66         r = vsnprintf (s, (size_t) n, format, ap);
  67         va_end (ap);
  68
  69         return r;
  70 }
  71 #endif /* def HAVE_VSNPRINTF */
  72
  73 gint32
  74 Mono_Posix_Stdlib__IOFBF (void)
  75 {
  76         return _IOFBF;
  77 }
  78
  79 gint32
  80 Mono_Posix_Stdlib__IOLBF (void)
  81 {
  82         return _IOLBF;
  83 }
  84
  85 gint32
  86 Mono_Posix_Stdlib__IONBF (void)
  87 {
  88         return _IONBF;
  89 }
  90
  91 gint32
  92 Mono_Posix_Stdlib_BUFSIZ (void)
  93 {
  94         return BUFSIZ;
  95 }
  96
  97 gint32
  98 Mono_Posix_Stdlib_EOF (void)
  99 {
 100         return EOF;
 101 }
 102
 103 gint32
 104 Mono_Posix_Stdlib_FOPEN_MAX (void)
 105 {
 106         return FOPEN_MAX;
 107 }
 108
 109 gint32
 110 Mono_Posix_Stdlib_FILENAME_MAX (void)
 111 {
 112         return FILENAME_MAX;
 113 }
 114
 115 gint32
 116 Mono_Posix_Stdlib_L_tmpnam (void)
 117 {
 118         return L_tmpnam;
 119 }
 120
 121 void*
 122 Mono_Posix_Stdlib_stdin (void)
 123 {
 124         return stdin;
 125 }
 126
 127 void*
 128 Mono_Posix_Stdlib_stdout (void)
 129 {
 130         return stdout;
 131 }
 132
 133 void*
 134 Mono_Posix_Stdlib_stderr (void)
 135 {
 136         return stderr;
 137 }
 138
 139 gint32
 140 Mono_Posix_Stdlib_TMP_MAX (void)
 141 {
 142         return TMP_MAX;
 143 }
 144
 145 void*
 146 Mono_Posix_Stdlib_tmpfile (void)
 147 {
 148         return tmpfile ();
 149 }
 150
 151 gint32
 152 Mono_Posix_Stdlib_setvbuf (void* stream, void *buf, int mode, mph_size_t size)
 153 {
 154         mph_return_if_size_t_overflow (size);
 155         return setvbuf (stream, (char *) buf, mode, (size_t) size);
 156 }
 157
 158 int
 159 Mono_Posix_Stdlib_setbuf (void* stream, void* buf)
 160 {
 161         setbuf (stream, buf);
 162         return 0;
 163 }
 164
 165 void*
 166 Mono_Posix_Stdlib_fopen (char* path, char* mode)
 167 {
 168         return fopen (path, mode);
 169 }
 170
 171 void*
 172 Mono_Posix_Stdlib_freopen (char* path, char* mode, void *stream)
 173 {
 174         return freopen (path, mode, stream);
 175 }
 176
 177 gint32
 178 Mono_Posix_Stdlib_fprintf (void* stream, char* format, char *message)
 179 {
 180         return fprintf (stream, format, message);
 181 }
 182
 183 gint32
 184 Mono_Posix_Stdlib_fgetc (void* stream)
 185 {
 186         return fgetc (stream);
 187 }
 188
 189 char*
 190 Mono_Posix_Stdlib_fgets (char* str, gint32 size, void* stream)
 191 {
 192         return fgets (str, size, stream);
 193 }
 194
 195 gint32
 196 Mono_Posix_Stdlib_fputc (gint32 c, void* stream)
 197 {
 198         return fputc (c, stream);
 199 }
 200
 201 gint32
 202 Mono_Posix_Stdlib_fputs (char* s, void* stream)
 203 {
 204         return fputs (s, stream);
 205 }
 206
 207 gint32
 208 Mono_Posix_Stdlib_fclose (void* stream)
 209 {
 210         return fclose (stream);
 211 }
 212
 213 gint32
 214 Mono_Posix_Stdlib_fflush (void* stream)
 215 {
 216         return fflush (stream);
 217 }
 218
 219 gint32
 220 Mono_Posix_Stdlib_fseek (void* stream, gint64 offset, int origin)
 221 {
 222         mph_return_if_long_overflow (offset);
 223
 224         return fseek (stream, offset, origin);
 225 }
 226
 227 gint64
 228 Mono_Posix_Stdlib_ftell (void* stream)
 229 {
 230         return ftell (stream);
 231 }
 232
 233 void*
 234 Mono_Posix_Stdlib_CreateFilePosition (void)
 235 {
 236         fpos_t* pos = malloc (sizeof(fpos_t));
 237         return pos;
 238 }
 239
 240 gint32
 241 Mono_Posix_Stdlib_fgetpos (void* stream, void *pos)
 242 {
 243         return fgetpos (stream, (fpos_t*) pos);
 244 }
 245
 246 gint32
 247 Mono_Posix_Stdlib_fsetpos (void* stream, void *pos)
 248 {
 249         return fsetpos (stream, (fpos_t*) pos);
 250 }
 251
 252 int
 253 Mono_Posix_Stdlib_rewind (void* stream)
 254 {
 255         do {
 256                 rewind (stream);
 257         } while (errno == EINTR);
 258         mph_return_if_val_in_list5(errno, EAGAIN, EBADF, EFBIG, EINVAL, EIO);
 259         mph_return_if_val_in_list5(errno, ENOSPC, ENXIO, EOVERFLOW, EPIPE, ESPIPE);
 260         return 0;
 261 }
 262
 263 int
 264 Mono_Posix_Stdlib_clearerr (void* stream)
 265 {
 266         clearerr (((FILE*) stream));
 267         return 0;
 268 }
 269
 270 gint32
 271 Mono_Posix_Stdlib_ungetc (gint32 c, void* stream)
 272 {
 273         return ungetc (c, stream);
 274 }
 275
 276 gint32
 277 Mono_Posix_Stdlib_feof (void* stream)
 278 {
 279         return feof (stream);
 280 }
 281
 282 gint32
 283 Mono_Posix_Stdlib_ferror (void* stream)
 284 {
 285         return ferror (stream);
 286 }
 287
 288 int
 289 Mono_Posix_Stdlib_perror (const char* s, int err)
 290 {
 291         errno = err;
 292         perror (s);
 293         return 0;
 294 }
 295
 296 #define MPH_FPOS_LENGTH (sizeof(fpos_t)*2)
 297
 298 int
 299 Mono_Posix_Stdlib_DumpFilePosition (char *dest, void *pos, gint32 len)
 300 {
 301         char *destp;
 302         unsigned char *posp, *pose;
 303
 304         if (dest == NULL)
 305                 return MPH_FPOS_LENGTH;
 306
 307         if (pos == NULL || len <= 0) {
 308                 errno = EINVAL;
 309                 return -1;
 310         }
 311
 312         posp = (unsigned char*) pos;
 313         pose = posp + sizeof(fpos_t);
 314         destp = dest;
 315
 316         for ( ; posp < pose && len > 1; destp += 2, ++posp, len -= 2) {
 317                 sprintf (destp, "%02X", *posp);
 318         }
 319
 320         if (len)
 321                 dest[MPH_FPOS_LENGTH] = '\0';
 322
 323         return destp - dest;
 324 }
 325
 326 G_END_DECLS
 327
 328 /*
 329  * vim: noexpandtab
 330  */