programs/libc/stdio.c

   1 /*
   2 Copyright (C) 2008  Mathias Gottschlag
   3
   4 Permission is hereby granted, free of charge, to any person obtaining a copy of
   5 this software and associated documentation files (the "Software"), to deal in the
   6 Software without restriction, including without limitation the rights to use,
   7 copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
   8 Software, and to permit persons to whom the Software is furnished to do so,
   9 subject to the following conditions:
  10
  11 The above copyright notice and this permission notice shall be included in all
  12 copies or substantial portions of the Software.
  13
  14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
  15 INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  16 PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  17 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  18 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  19 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  20 */
  21
  22 #include <stdio.h>
  23 #include <fcntl.h>
  24 #include <string.h>
  25 #include <stdlib.h>
  26
  27 #define ERROR_EOF 1
  28 #define ERROR_ERROR 2
  29
  30 struct FILE
  31 {
  32         int fd;
  33         int append;
  34         int error;
  35 };
  36
  37 FILE *stderr = 0;
  38 FILE *stdout = 0;
  39 FILE *stdin = 0;
  40
  41 FILE *fopen(const char *filename, const char *mode)
  42 {
  43         // Open file
  44         int openmode = 0;
  45         if (strchr(mode, 'r')) openmode = O_RDONLY;
  46         else if (strchr(mode, 'w')) openmode = O_WRONLY | O_CREAT;
  47         else if (strchr(mode, 'a')) openmode = O_WRONLY | O_CREAT;
  48         if (strchr(mode, '+')) openmode = (openmode & ~O_ACCMODE) | O_RDWR;
  49         int fd = open(filename, openmode);
  50         if (fd == -1) return 0;
  51         // Return file structure
  52         FILE *file = malloc(sizeof(FILE));
  53         memset(file, 0, sizeof(FILE));
  54         file->fd = fd;
  55         if (strchr(mode, 'a')) file->append = 1;
  56         return file;
  57 }
  58 int fclose(FILE *file)
  59 {
  60         if (!file) return EOF;
  61         close(file->fd);
  62         free(file);
  63         return 0;
  64 }
  65 FILE *freopen(const char *filename, const char *mode, FILE *file)
  66 {
  67         if (fclose(file) == EOF) return 0;
  68         return fopen(filename, mode);
  69 }
  70 int feof(FILE *file)
  71 {
  72         return (file->error & ERROR_EOF) != 0;
  73 }
  74 int ferror(FILE *file)
  75 {
  76         return (file->error & ERROR_ERROR) != 0;
  77 }
  78 int fseek(FILE *file, long int offset, int origin)
  79 {
  80         if (!file) return EOF;
  81         file->error = 0;
  82         if (lseek(file->fd, offset, origin) == (off_t)-1) return EOF;
  83         return 0;
  84 }
  85 long int ftell(FILE *file)
  86 {
  87         if (!file) return EOF;
  88         long int pos = lseek(file->fd, 0, SEEK_CUR);
  89         return pos;
  90 }
  91 void rewind(FILE *file)
  92 {
  93         fseek(file, 0, SEEK_SET);
  94 }
  95 void clearerr(FILE *file)
  96 {
  97         file->error = 0;
  98 }
  99
 100 int fgetpos(FILE *file, fpos_t *pos)
 101 {
 102         if (!file || !pos) return EOF;
 103
 104         long int position = lseek(file->fd, 0, SEEK_CUR);
 105         if (position == -1)
 106         {
 107                 *pos = 0;
 108                 return EOF;
 109         }
 110         *pos = position;
 111         return 0;
 112 }
 113 int fsetpos(FILE *file, const fpos_t *pos)
 114 {
 115         if (!file || !pos) return EOF;
 116         file->error = 0;
 117         if (lseek(file->fd, *pos, SEEK_SET) == (off_t)-1) return -1;
 118         return 0;
 119 }
 120
 121 int fgetc(FILE *file)
 122 {
 123         if (!file) return EOF;
 124         char c = 0;
 125         int size = read(file->fd, &c, 1);
 126         if (size == 0)
 127         {
 128                 file->error = ERROR_EOF;
 129                 return EOF;
 130         }
 131         else if (size == -1)
 132         {
 133                 file->error = ERROR_ERROR;
 134                 return EOF;
 135         }
 136         return c;
 137 }
 138 char *fgets(char *str, int num, FILE *file)
 139 {
 140         int n = 0;
 141         while (n < num)
 142         {
 143                 char c = fgetc(file);
 144                 if ((c == EOF) && ferror(file)) return 0;
 145                 if ((c == EOF) && (n == 0))
 146                 {
 147                         return 0;
 148                 }
 149                 else if ((c == EOF) || (c == '\n') || (c == 0))
 150                 {
 151                         str[n] = 0;
 152                         return str;
 153                 }
 154                 else
 155                 {
 156                         str[n] = c;
 157                 }
 158                 n++;
 159         }
 160         str[n - 1] = 0;
 161         return str;
 162 }
 163 int fscanf(FILE *file, const char *fmt, ...)
 164 {
 165         return -1;
 166 }
 167 size_t fread(void *ptr, size_t size, size_t count, FILE *file)
 168 {
 169         if (!file) return 0;
 170         int bytecount = read(file->fd, ptr, size * count);
 171         if (bytecount == -1)
 172         {
 173                 file->error = ERROR_ERROR;
 174                 return 0;
 175         }
 176         if (bytecount != (int)(size * count))
 177         {
 178                 file->error = ERROR_EOF;
 179         }
 180         return bytecount;
 181 }
 182
 183 int fputc(int c, FILE *file)
 184 {
 185         if (!file) return EOF;
 186         if (file->append) lseek(file->fd, 0, SEEK_END);
 187         int size = write(file->fd, &c, 1);
 188         if (size == 0)
 189         {
 190                 file->error = ERROR_EOF;
 191                 return EOF;
 192         }
 193         else if (size == -1)
 194         {
 195                 file->error = ERROR_ERROR;
 196                 return EOF;
 197         }
 198         return c;
 199 }
 200 int fputs(const char *s, FILE *file)
 201 {
 202         if (!file) return EOF;
 203         if (file->append) lseek(file->fd, 0, SEEK_END);
 204         int size = write(file->fd, s, strlen(s));
 205         if (size == -1)
 206         {
 207                 file->error = ERROR_ERROR;
 208                 return EOF;
 209         }
 210         return size;
 211 }
 212 int vfprintf(FILE *file, const char *fmt, va_list args)
 213 {
 214         if (!file) return EOF;
 215         if (file->append) lseek(file->fd, 0, SEEK_END);
 216         // FIXME: Greater length?
 217         char buffer[1024];
 218         vsnprintf(buffer, 1024, fmt, args);
 219
 220         int written = write(file->fd, buffer, strlen(buffer));
 221         if (written == -1)
 222         {
 223                 file->error = ERROR_ERROR;
 224                 return EOF;
 225         }
 226         return written;
 227 }
 228 int fprintf(FILE *file, const char *fmt, ...)
 229 {
 230         if (!file) return EOF;
 231         if (file->append) lseek(file->fd, 0, SEEK_END);
 232         // FIXME: Greater length?
 233         char buffer[1024];
 234         va_list args;
 235         va_start(args, fmt);
 236         vsnprintf(buffer, 1024, fmt, args);
 237         va_end(args);
 238
 239         int written = write(file->fd, buffer, strlen(buffer));
 240         if (written == -1)
 241         {
 242                 file->error = ERROR_ERROR;
 243                 return EOF;
 244         }
 245         return written;
 246 }
 247 size_t fwrite(const void *ptr, size_t size, size_t count, FILE *file)
 248 {
 249         if (!file) return EOF;
 250         if (file->append) lseek(file->fd, 0, SEEK_END);
 251         int written = write(file->fd, ptr, size * count);
 252         if (written == -1) return EOF;
 253         return written;
 254 }
 255
 256 int fileno(FILE *file)
 257 {
 258         if (!file) return -1;
 259         return file->fd;
 260 }
 261
 262 FILE *tmpfile(void)
 263 {
 264         // TODO
 265         return 0;
 266 }
 267 char *tmpnam(char *s)
 268 {
 269         // TODO
 270         return s;
 271 }
 272
 273 int ungetc(int character, FILE *file)
 274 {
 275         return EOF;
 276 }
 277
 278 int rename(const char *oldname, const char *newname)
 279 {
 280         return -1;
 281 }
 282 int remove(const char *filename)
 283 {
 284         return -1;
 285 }
 286
 287 int printf(const char *fmt, ...)
 288 {
 289         va_list args;
 290         va_start(args, fmt);
 291         int status = vfprintf(stdout, fmt, args);
 292         va_end(args);
 293         return status;
 294 }
 295 int puts(const char *s)
 296 {
 297         printf("%s\n", s);
 298         return 0;
 299 }
 300 int putc(int c, FILE *file)
 301 {
 302         return fputc(c, file);
 303 }
 304 int putchar(int c)
 305 {
 306         return fputc(c, stdout);
 307 }
 308 int getchar(void)
 309 {
 310         return fgetc(stdin);
 311 }
 312
 313 void perror(const char *str)
 314 {
 315         printf("%s\n", str);
 316 }
 317
 318 int fflush(FILE *file)
 319 {
 320         return 0;
 321 }
 322
 323 int setvbuf(FILE *file, char *buf, int type, size_t size)
 324 {
 325         return 0;
 326 }
 327
 328 int scanf(const char *format, ... )
 329 {
 330         return -1;
 331 }
 332 int sscanf(const char *s, const char *format, ... )
 333 {
 334         return -1;
 335 }
 336