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 PLATFORM_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         return L_cuserid;
  30 }
  31 #endif /* ndef PLATFORM_WIN32 */
  32
  33 mph_size_t
  34 Mono_Posix_Stdlib_fread (unsigned char *ptr, mph_size_t size, mph_size_t nmemb, void *stream)
  35 {
  36         mph_return_if_size_t_overflow (size);
  37         mph_return_if_size_t_overflow (nmemb);
  38
  39         return fread (ptr, (size_t) size, (size_t) nmemb, (FILE*) stream);
  40 }
  41
  42 mph_size_t
  43 Mono_Posix_Stdlib_fwrite (unsigned char *ptr, mph_size_t size, mph_size_t nmemb, void *stream)
  44 {
  45         mph_return_if_size_t_overflow (size);
  46         mph_return_if_size_t_overflow (nmemb);
  47
  48         return fwrite (ptr, (size_t) size, (size_t) nmemb, (FILE*) stream);
  49 }
  50
  51 #ifdef HAVE_VSNPRINTF
  52 gint32
  53 Mono_Posix_Stdlib_snprintf (char *s, mph_size_t n, char *format, ...);
  54 gint32
  55 Mono_Posix_Stdlib_snprintf (char *s, mph_size_t n, char *format, ...)
  56 {
  57         va_list ap;
  58         gint32 r;
  59         mph_return_if_size_t_overflow (n);
  60
  61         va_start (ap, format);
  62         r = vsnprintf (s, (size_t) n, format, ap);
  63         va_end (ap);
  64
  65         return r;
  66 }
  67 #endif /* def HAVE_VSNPRINTF */
  68
  69 gint32
  70 Mono_Posix_Stdlib__IOFBF (void)
  71 {
  72         return _IOFBF;
  73 }
  74
  75 gint32
  76 Mono_Posix_Stdlib__IOLBF (void)
  77 {
  78         return _IOLBF;
  79 }
  80
  81 gint32
  82 Mono_Posix_Stdlib__IONBF (void)
  83 {
  84         return _IONBF;
  85 }
  86
  87 gint32
  88 Mono_Posix_Stdlib_BUFSIZ (void)
  89 {
  90         return BUFSIZ;
  91 }
  92
  93 gint32
  94 Mono_Posix_Stdlib_EOF (void)
  95 {
  96         return EOF;
  97 }
  98
  99 gint32
 100 Mono_Posix_Stdlib_FOPEN_MAX (void)
 101 {
 102         return FOPEN_MAX;
 103 }
 104
 105 gint32
 106 Mono_Posix_Stdlib_FILENAME_MAX (void)
 107 {
 108         return FILENAME_MAX;
 109 }
 110
 111 gint32
 112 Mono_Posix_Stdlib_L_tmpnam (void)
 113 {
 114         return L_tmpnam;
 115 }
 116
 117 void*
 118 Mono_Posix_Stdlib_stdin (void)
 119 {
 120         return stdin;
 121 }
 122
 123 void*
 124 Mono_Posix_Stdlib_stdout (void)
 125 {
 126         return stdout;
 127 }
 128
 129 void*
 130 Mono_Posix_Stdlib_stderr (void)
 131 {
 132         return stderr;
 133 }
 134
 135 gint32
 136 Mono_Posix_Stdlib_TMP_MAX (void)
 137 {
 138         return TMP_MAX;
 139 }
 140
 141 gint32
 142 Mono_Posix_Stdlib_setvbuf (void* stream, void *buf, int mode, mph_size_t size)
 143 {
 144         mph_return_if_size_t_overflow (size);
 145         return setvbuf (stream, (char *) buf, mode, (size_t) size);
 146 }
 147
 148 int
 149 Mono_Posix_Stdlib_setbuf (void* stream, void* buf)
 150 {
 151         errno = 0;
 152         setbuf (stream, buf);
 153         return errno == 0 ? 0 : -1;
 154 }
 155
 156 gint32
 157 Mono_Posix_Stdlib_fseek (void* stream, gint64 offset, int origin)
 158 {
 159         mph_return_if_long_overflow (offset);
 160
 161         return fseek (stream, offset, origin);
 162 }
 163
 164 gint64
 165 Mono_Posix_Stdlib_ftell (void* stream)
 166 {
 167         return ftell (stream);
 168 }
 169
 170 void*
 171 Mono_Posix_Stdlib_CreateFilePosition (void)
 172 {
 173         fpos_t* pos = malloc (sizeof(fpos_t));
 174         return pos;
 175 }
 176
 177 gint32
 178 Mono_Posix_Stdlib_fgetpos (void* stream, void *pos)
 179 {
 180         return fgetpos (stream, (fpos_t*) pos);
 181 }
 182
 183 gint32
 184 Mono_Posix_Stdlib_fsetpos (void* stream, void *pos)
 185 {
 186         return fsetpos (stream, (fpos_t*) pos);
 187 }
 188
 189 int
 190 Mono_Posix_Stdlib_rewind (void* stream)
 191 {
 192         errno = 0;
 193         rewind (stream);
 194         return errno == 0 ? 0 : -1;
 195 }
 196
 197 int
 198 Mono_Posix_Stdlib_clearerr (void* stream)
 199 {
 200         errno = 0;
 201         clearerr (((FILE*) stream));
 202         return errno == 0 ? 0 : -1;
 203 }
 204
 205 int
 206 Mono_Posix_Stdlib_perror (const char* s)
 207 {
 208         errno = 0;
 209         perror (s);
 210         return errno == 0 ? 0 : -1;
 211 }
 212
 213 #define MPH_FPOS_LENGTH (sizeof(fpos_t)*2)
 214
 215 int
 216 Mono_Posix_Stdlib_DumpFilePosition (char *dest, void *pos, gint32 len)
 217 {
 218         char *destp;
 219         unsigned char *posp, *pose;
 220
 221         if (dest == NULL)
 222                 return MPH_FPOS_LENGTH;
 223
 224         if (pos == NULL || len <= 0) {
 225                 errno = EINVAL;
 226                 return -1;
 227         }
 228
 229         posp = (unsigned char*) pos;
 230         pose = posp + sizeof(fpos_t);
 231         destp = dest;
 232
 233         for ( ; posp < pose && len > 1; destp += 2, ++posp, len -= 2) {
 234                 sprintf (destp, "%02X", *posp);
 235         }
 236
 237         if (len)
 238                 dest[MPH_FPOS_LENGTH] = '\0';
 239
 240         return destp - dest;
 241 }
 242
 243 G_END_DECLS
 244
 245 /*
 246  * vim: noexpandtab
 247  */