Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/io/io.c

    ra35b458 r1b20da0  
    119119                list_append(&stdin->link, &files);
    120120        }
    121 
     121       
    122122        int outfd = inbox_get("stdout");
    123123        if (outfd >= 0) {
    … …  
    133133                list_append(&stdout->link, &files);
    134134        }
    135 
     135       
    136136        int errfd = inbox_get("stderr");
    137137        if (errfd >= 0) {
    … …  
    165165                return false;
    166166        }
    167 
     167       
    168168        if ((*mp == 'b') || (*mp == 't'))
    169169                mp++;
    170 
     170       
    171171        bool plus;
    172172        if (*mp == '+') {
    … …  
    175175        } else
    176176                plus = false;
    177 
     177       
    178178        if (*mp != 0) {
    179179                errno = EINVAL;
    … …  
    183183        *create = false;
    184184        *truncate = false;
    185 
     185       
    186186        /* Parse first character of fmode and determine mode for vfs_open(). */
    187187        switch (fmode[0]) {
    … …  
    209209                return false;
    210210        }
    211 
     211       
    212212        return true;
    213213}
    … …  
    241241{
    242242        /* FIXME: Use more complex rules for setting buffering options. */
    243 
     243       
    244244        switch (stream->fd) {
    245245        case 1:
    … …  
    259259{
    260260        assert(stream->buf == NULL);
    261 
     261       
    262262        stream->buf = malloc(stream->buf_size);
    263263        if (stream->buf == NULL) {
    … …  
    265265                return EOF;
    266266        }
    267 
     267       
    268268        stream->buf_head = stream->buf;
    269269        stream->buf_tail = stream->buf;
    … …  
    285285        if (!parse_mode(fmode, &mode, &create, &truncate))
    286286                return NULL;
    287 
     287       
    288288        /* Open file. */
    289289        FILE *stream = malloc(sizeof(FILE));
    … …  
    311311                return NULL;
    312312        }
    313 
     313       
    314314        if (truncate) {
    315315                rc = vfs_resize(file, 0);
    … …  
    331331        _setvbuf(stream);
    332332        stream->ungetc_chars = 0;
    333 
     333       
    334334        list_append(&stream->link, &files);
    335 
     335       
    336336        return stream;
    337337}
    … …  
    345345                return NULL;
    346346        }
    347 
     347       
    348348        stream->fd = fd;
    349349        stream->pos = 0;
    … …  
    355355        _setvbuf(stream);
    356356        stream->ungetc_chars = 0;
    357 
     357       
    358358        list_append(&stream->link, &files);
    359 
     359       
    360360        return stream;
    361361}
    … …  
    365365{
    366366        errno_t rc = 0;
    367 
     367       
    368368        fflush(stream);
    369 
     369       
    370370        if (stream->sess != NULL)
    371371                async_hangup(stream->sess);
    372 
     372       
    373373        if (stream->fd >= 0)
    374374                rc = vfs_put(stream->fd);
    375 
     375       
    376376        list_remove(&stream->link);
    377 
     377       
    378378        if (rc != EOK) {
    379379                errno = rc;
    380380                return EOF;
    381381        }
    382 
     382       
    383383        return 0;
    384384}
    … …  
    387387{
    388388        int rc = _fclose_nofree(stream);
    389 
     389       
    390390        if ((stream != &stdin_null)
    391391            && (stream != &stdout_kio)
    392392            && (stream != &stderr_kio))
    393393                free(stream);
    394 
     394       
    395395        return rc;
    396396}
    … …  
    399399{
    400400        FILE *nstr;
    401 
     401       
    402402        if (path == NULL) {
    403403                /* Changing mode is not supported */
    404404                return NULL;
    405405        }
    406 
     406       
    407407        (void) _fclose_nofree(stream);
    408408        nstr = fopen(path, mode);
    … …  
    411411                return NULL;
    412412        }
    413 
     413       
    414414        list_remove(&nstr->link);
    415415        *stream = *nstr;
    416416        list_append(&stream->link, &files);
    417 
     417       
    418418        free(nstr);
    419 
     419       
    420420        return stream;
    421421}
    … …  
    659659                        return 0; /* Errno set by _fallocbuf(). */
    660660        }
    661 
     661       
    662662        data = (uint8_t *) buf;
    663663        bytes_left = size * nmemb;
    664664        total_written = 0;
    665665        need_flush = false;
    666 
     666       
    667667        while ((!stream->error) && (bytes_left > 0)) {
    668668                buf_free = stream->buf_size - (stream->buf_head - stream->buf);
    … …  
    671671                else
    672672                        now = bytes_left;
    673 
     673               
    674674                for (i = 0; i < now; i++) {
    675675                        b = data[i];
    676676                        stream->buf_head[i] = b;
    677 
     677                       
    678678                        if ((b == '\n') && (stream->btype == _IOLBF))
    679679                                need_flush = true;
    680680                }
    681 
     681               
    682682                data += now;
    683683                stream->buf_head += now;
    … …  
    686686                total_written += now;
    687687                stream->buf_state = _bs_write;
    688 
     688               
    689689                if (buf_free == 0) {
    690690                        /* Only need to drain buffer. */
    … …  
    697697        if (need_flush)
    698698                fflush(stream);
    699 
     699       
    700700        return (total_written / size);
    701701}
    … …  
    705705        char buf[STR_BOUNDS(1)];
    706706        size_t sz = 0;
    707 
     707       
    708708        if (chr_encode(c, buf, &sz, STR_BOUNDS(1)) == EOK) {
    709709                size_t wr = fwrite(buf, 1, sz, stream);
    710 
     710               
    711711                if (wr < sz)
    712712                        return EOF;
    713 
     713               
    714714                return (int) c;
    715715        }
    716 
     716       
    717717        return EOF;
    718718}
    … …  
    739739{
    740740        char c;
    741 
     741       
    742742        /* This could be made faster by only flushing when needed. */
    743743        if (stdout)
    … …  
    745745        if (stderr)
    746746                fflush(stderr);
    747 
     747       
    748748        if (fread(&c, sizeof(char), 1, stream) < sizeof(char))
    749749                return EOF;
    750 
     750       
    751751        return (int) c;
    752752}
    … …  
    841841        if (stream->error)
    842842                return EOF;
    843 
     843       
    844844        _fflushbuf(stream);
    845845        if (stream->error) {
    … …  
    876876        if (stream->error)
    877877                return EOF;
    878 
     878       
    879879        _fflushbuf(stream);
    880880        if (stream->error) {
    … …  
    882882                return EOF;
    883883        }
    884 
     884       
    885885        if (stream->kio) {
    886886                kio_update();
    887887                return 0;
    888888        }
    889 
     889       
    890890        if ((stream->fd >= 0) && (stream->need_sync)) {
    891891                errno_t rc;
    … …  
    904904                return 0;
    905905        }
    906 
     906       
    907907        return 0;
    908908}
    … …  
    930930                return EOF;
    931931        }
    932 
     932       
    933933        return stream->fd;
    934934}
    … …  
    939939                if (stream->sess == NULL)
    940940                        stream->sess = vfs_fd_session(stream->fd, iface);
    941 
     941               
    942942                return stream->sess;
    943943        }
    944 
     944       
    945945        return NULL;
    946946}
    … …  
    952952                return EOK;
    953953        }
    954 
     954       
    955955        return ENOENT;
    956956}
Note: See TracChangeset for help on using the changeset viewer.