Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changes in / [a55d76b1:be2a20ac] in mainline


Ignore:
Location:
uspace/lib
Files:
5 added
1 deleted
8 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/Makefile

    ra55d76b1 rbe2a20ac  
    131131        generic/double_to_str.c \
    132132        generic/malloc.c \
     133        generic/stdio/scanf.c \
     134        generic/stdio/sscanf.c \
     135        generic/stdio/sstream.c \
    133136        generic/sysinfo.c \
    134137        generic/ipc.c \
     
    185188        test/main.c \
    186189        test/io/table.c \
     190        test/stdio/scanf.c \
    187191        test/odict.c \
    188192        test/qsort.c \
  • uspace/lib/c/generic/io/io.c

    ra55d76b1 rbe2a20ac  
    5353static void _fflushbuf(FILE *stream);
    5454
     55static size_t stdio_kio_read(void *, size_t, size_t, FILE *);
     56static size_t stdio_kio_write(const void *, size_t, size_t, FILE *);
     57static int stdio_kio_flush(FILE *);
     58
     59static size_t stdio_vfs_read(void *, size_t, size_t, FILE *);
     60static size_t stdio_vfs_write(const void *, size_t, size_t, FILE *);
     61
     62static int stdio_vfs_flush(FILE *);
     63
     64/** KIO stream ops */
     65static __stream_ops_t stdio_kio_ops = {
     66        .read = stdio_kio_read,
     67        .write = stdio_kio_write,
     68        .flush = stdio_kio_flush
     69};
     70
     71/** VFS stream ops */
     72static __stream_ops_t stdio_vfs_ops = {
     73        .read = stdio_vfs_read,
     74        .write = stdio_vfs_write,
     75        .flush = stdio_vfs_flush
     76};
     77
    5578static FILE stdin_null = {
    5679        .fd = -1,
     
    5881        .error = true,
    5982        .eof = true,
    60         .kio = false,
     83        .ops = &stdio_vfs_ops,
     84        .arg = NULL,
    6185        .sess = NULL,
    6286        .btype = _IONBF,
     
    7397        .error = false,
    7498        .eof = false,
    75         .kio = true,
     99        .ops = &stdio_kio_ops,
     100        .arg = NULL,
    76101        .sess = NULL,
    77102        .btype = _IOLBF,
     
    88113        .error = false,
    89114        .eof = false,
    90         .kio = true,
     115        .ops = &stdio_kio_ops,
     116        .arg = NULL,
    91117        .sess = NULL,
    92118        .btype = _IONBF,
     
    328354        stream->error = false;
    329355        stream->eof = false;
    330         stream->kio = false;
     356        stream->ops = &stdio_vfs_ops;
     357        stream->arg = NULL;
    331358        stream->sess = NULL;
    332359        stream->need_sync = false;
     
    352379        stream->error = false;
    353380        stream->eof = false;
    354         stream->kio = false;
     381        stream->ops = &stdio_vfs_ops;
     382        stream->arg = NULL;
    355383        stream->sess = NULL;
    356384        stream->need_sync = false;
     
    435463static size_t _fread(void *buf, size_t size, size_t nmemb, FILE *stream)
    436464{
    437         errno_t rc;
    438         size_t nread;
    439 
    440         if (size == 0 || nmemb == 0)
    441                 return 0;
    442 
    443         rc = vfs_read(stream->fd, &stream->pos, buf, size * nmemb, &nread);
    444         if (rc != EOK) {
    445                 errno = rc;
    446                 stream->error = true;
    447         } else if (nread == 0) {
    448                 stream->eof = true;
    449         }
    450 
    451         return (nread / size);
     465        return stream->ops->read(buf, size, nmemb, stream);
    452466}
    453467
     
    464478static size_t _fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream)
    465479{
    466         errno_t rc;
    467480        size_t nwritten;
    468481
     
    470483                return 0;
    471484
    472         if (stream->kio) {
    473                 rc = kio_write(buf, size * nmemb, &nwritten);
    474                 if (rc != EOK) {
    475                         stream->error = true;
    476                         nwritten = 0;
    477                 }
    478         } else {
    479                 rc = vfs_write(stream->fd, &stream->pos, buf, size * nmemb,
    480                     &nwritten);
    481                 if (rc != EOK) {
    482                         errno = rc;
    483                         stream->error = true;
    484                 }
    485         }
     485        nwritten = stream->ops->write(buf, size, nmemb, stream);
    486486
    487487        if (nwritten > 0)
     
    905905        }
    906906
    907         if (stream->kio) {
    908                 kio_update();
    909                 return 0;
    910         }
    911 
    912         if ((stream->fd >= 0) && (stream->need_sync)) {
    913                 errno_t rc;
    914 
     907        if (stream->need_sync) {
    915908                /**
    916909                 * Better than syncing always, but probably still not the
    917910                 * right thing to do.
    918911                 */
     912                if (stream->ops->flush(stream) == EOF)
     913                        return EOF;
     914
    919915                stream->need_sync = false;
    920                 rc = vfs_sync(stream->fd);
    921                 if (rc != EOK) {
    922                         errno = rc;
    923                         return EOF;
    924                 }
    925 
    926                 return 0;
    927916        }
    928917
     
    948937int fileno(FILE *stream)
    949938{
    950         if (stream->kio) {
     939        if (stream->ops != &stdio_vfs_ops) {
    951940                errno = EBADF;
    952941                return EOF;
     
    978967}
    979968
     969/** Read from KIO stream. */
     970static size_t stdio_kio_read(void *buf, size_t size, size_t nmemb, FILE *stream)
     971{
     972        stream->eof = true;
     973        return 0;
     974}
     975
     976/** Write to KIO stream. */
     977static size_t stdio_kio_write(const void *buf, size_t size, size_t nmemb,
     978    FILE *stream)
     979{
     980        errno_t rc;
     981        size_t nwritten;
     982
     983        rc = kio_write(buf, size * nmemb, &nwritten);
     984        if (rc != EOK) {
     985                stream->error = true;
     986                nwritten = 0;
     987        }
     988
     989        return nwritten / size;
     990}
     991
     992/** Flush KIO stream. */
     993static int stdio_kio_flush(FILE *stream)
     994{
     995        kio_update();
     996        return 0;
     997}
     998
     999/** Read from VFS stream. */
     1000static size_t stdio_vfs_read(void *buf, size_t size, size_t nmemb, FILE *stream)
     1001{
     1002        errno_t rc;
     1003        size_t nread;
     1004
     1005        if (size == 0 || nmemb == 0)
     1006                return 0;
     1007
     1008        rc = vfs_read(stream->fd, &stream->pos, buf, size * nmemb, &nread);
     1009        if (rc != EOK) {
     1010                errno = rc;
     1011                stream->error = true;
     1012        } else if (nread == 0) {
     1013                stream->eof = true;
     1014        }
     1015
     1016        return (nread / size);
     1017}
     1018
     1019/** Write to VFS stream. */
     1020static size_t stdio_vfs_write(const void *buf, size_t size, size_t nmemb,
     1021    FILE *stream)
     1022{
     1023        errno_t rc;
     1024        size_t nwritten;
     1025
     1026        rc = vfs_write(stream->fd, &stream->pos, buf, size * nmemb, &nwritten);
     1027        if (rc != EOK) {
     1028                errno = rc;
     1029                stream->error = true;
     1030        }
     1031
     1032        return nwritten / size;
     1033}
     1034
     1035/** Flush VFS stream. */
     1036static int stdio_vfs_flush(FILE *stream)
     1037{
     1038        errno_t rc;
     1039
     1040        rc = vfs_sync(stream->fd);
     1041        if (rc != EOK) {
     1042                errno = rc;
     1043                return EOF;
     1044        }
     1045
     1046        return 0;
     1047}
     1048
    9801049/** @}
    9811050 */
  • uspace/lib/c/generic/private/stdio.h

    ra55d76b1 rbe2a20ac  
    3939#include <stdio.h>
    4040#include <async.h>
     41#include <stddef.h>
    4142
    4243/** Maximum characters that can be pushed back by ungetc() */
    4344#define UNGETC_MAX 1
     45
     46/** Stream operations */
     47typedef struct {
     48        /** Read from stream */
     49        size_t (*read)(void *buf, size_t size, size_t nmemb, FILE *stream);
     50        /** Write to stream */
     51        size_t (*write)(const void *buf, size_t size, size_t nmemb,
     52            FILE *stream);
     53        /** Flush stream */
     54        int (*flush)(FILE *stream);
     55} __stream_ops_t;
    4456
    4557struct _IO_FILE {
     
    4759        link_t link;
    4860
     61        /** Stream operations */
     62        __stream_ops_t *ops;
     63
    4964        /** Underlying file descriptor. */
    5065        int fd;
     66
     67        /** Instance argument */
     68        void *arg;
    5169
    5270        /** File position. */
     
    5876        /** End-of-file indicator. */
    5977        int eof;
    60 
    61         /** KIO indicator */
    62         int kio;
    6378
    6479        /** Session to the file provider */
  • uspace/lib/c/include/stdio.h

    ra55d76b1 rbe2a20ac  
    101101extern int vsnprintf(char *, size_t, const char *, va_list);
    102102
     103/* Formatted input */
     104extern int scanf(const char *, ...);
     105extern int vscanf(const char *, va_list);
     106extern int fscanf(FILE *, const char *, ...);
     107extern int vfscanf(FILE *, const char *, va_list);
     108extern int sscanf(const char *, const char *, ...);
     109extern int vsscanf(const char *, const char *, va_list);
     110
    103111/* File stream functions */
    104112extern FILE *fopen(const char *, const char *);
  • uspace/lib/c/test/main.c

    ra55d76b1 rbe2a20ac  
    3636PCUT_IMPORT(odict);
    3737PCUT_IMPORT(qsort);
     38PCUT_IMPORT(scanf);
    3839PCUT_IMPORT(sprintf);
    3940PCUT_IMPORT(str);
  • uspace/lib/posix/Makefile

    ra55d76b1 rbe2a20ac  
    7070        src/signal.c \
    7171        src/stdio.c \
    72         src/stdio/scanf.c \
    7372        src/stdlib.c \
    7473        src/stdlib/strtold.c \
  • uspace/lib/posix/include/posix/stdio.h

    ra55d76b1 rbe2a20ac  
    164164extern int vsprintf(char *__restrict__ s, const char *__restrict__ format, va_list ap);
    165165
    166 /* Formatted Input */
    167 extern int fscanf(
    168     FILE *__restrict__ stream, const char *__restrict__ format, ...);
    169 extern int vfscanf(
    170     FILE *__restrict__ stream, const char *__restrict__ format, va_list arg);
    171 extern int scanf(const char *__restrict__ format, ...);
    172 extern int vscanf(const char *__restrict__ format, va_list arg);
    173 extern int sscanf(
    174     const char *__restrict__ s, const char *__restrict__ format, ...);
    175 extern int vsscanf(
    176     const char *__restrict__ s, const char *__restrict__ format, va_list arg);
    177 
    178166/* File Locking */
    179167extern void flockfile(FILE *file);
  • uspace/lib/posix/src/stdio.c

    ra55d76b1 rbe2a20ac  
    351351
    352352/**
    353  * Convert formatted input from the stream.
    354  *
    355  * @param stream Input stream.
    356  * @param format Format description.
    357  * @return The number of converted output items or EOF on failure.
    358  */
    359 int fscanf(FILE *restrict stream, const char *restrict format, ...)
    360 {
    361         va_list list;
    362         va_start(list, format);
    363         int result = vfscanf(stream, format, list);
    364         va_end(list);
    365         return result;
    366 }
    367 
    368 /**
    369  * Convert formatted input from the standard input.
    370  *
    371  * @param format Format description.
    372  * @return The number of converted output items or EOF on failure.
    373  */
    374 int scanf(const char *restrict format, ...)
    375 {
    376         va_list list;
    377         va_start(list, format);
    378         int result = vscanf(format, list);
    379         va_end(list);
    380         return result;
    381 }
    382 
    383 /**
    384  * Convert formatted input from the standard input.
    385  *
    386  * @param format Format description.
    387  * @param arg Output items.
    388  * @return The number of converted output items or EOF on failure.
    389  */
    390 int vscanf(const char *restrict format, va_list arg)
    391 {
    392         return vfscanf(stdin, format, arg);
    393 }
    394 
    395 /**
    396  * Convert formatted input from the string.
    397  *
    398  * @param s Input string.
    399  * @param format Format description.
    400  * @return The number of converted output items or EOF on failure.
    401  */
    402 int sscanf(const char *restrict s, const char *restrict format, ...)
    403 {
    404         va_list list;
    405         va_start(list, format);
    406         int result = vsscanf(s, format, list);
    407         va_end(list);
    408         return result;
    409 }
    410 
    411 /**
    412353 * Acquire file stream for the thread.
    413354 *
Note: See TracChangeset for help on using the changeset viewer.