Changeset a35b458 in mainline for uspace/lib/posix/src


Ignore:
Timestamp:
2018-03-02T20:10:49Z (7 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1380b7
Parents:
3061bc1
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

Location:
uspace/lib/posix/src
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/posix/src/dlfcn.c

    r3061bc1 ra35b458  
    4242                fprintf(stderr, "dlopen() not implemented with non-zero flags (%s:%d), something will NOT work.\n", __FILE__, __LINE__);
    4343        }
    44        
     44
    4545        return __helenos_libc_dlopen(filename, 0);
    4646}

  • uspace/lib/posix/src/fnmatch.c

    r3061bc1 ra35b458  
    301301                return COLL_ELM_INVALID;
    302302        }
    303        
     303
    304304        *pattern = p + 1;
    305305        return _coll_elm_char(*p);
    … …  
    359359                p++;
    360360        }
    361        
     361
    362362        coll_elm_t current_elm = COLL_ELM_INVALID;
    363        
     363
    364364        while (*p != ']') {
    365365                if (*p == '-' && *(p + 1) != ']' &&
    … …  
    374374                        continue;
    375375                }
    376        
     376
    377377                if (*p == '[' && *(p + 1) == ':') {
    378378                        current_elm = COLL_ELM_INVALID;
    … …  
    380380                        continue;
    381381                }
    382                
     382
    383383                current_elm = _next_coll_elm(&p, flags);
    384384                if (current_elm == COLL_ELM_INVALID) {
    … …  
    460460                                return false;
    461461                        }
    462                        
     462
    463463                        /* None of the above, match anything else. */
    464464                        p++;
    … …  
    496496
    497497        /* Entire sub-pattern matched. */
    498        
     498
    499499        /* postconditions */
    500500        assert(*p == '\0' || *p == '*');
    501501        assert(*p != '\0' || *s == '\0' || (leading_dir && *s == '/'));
    502        
     502
    503503        *pattern = p;
    504504        *string = s;
    … …  
    667667        match("helen??", "helenos", 0);
    668668        match("****booo****", "booo", 0);
    669        
     669
    670670        match("hello[[:space:]]world", "hello world", 0);
    671671        nomatch("hello[[:alpha:]]world", "hello world", 0);
    672        
     672
    673673        match("/hoooo*", "/hooooooo/hooo", 0);
    674674        nomatch("/hoooo*", "/hooooooo/hooo", FNM_PATHNAME);
    … …  
    680680        nomatch("/hoooo", "/hooooooo/hooo", FNM_LEADING_DIR);
    681681        match("/hooooooo", "/hooooooo/hooo", FNM_LEADING_DIR);
    682        
     682
    683683        match("*", "hell", 0);
    684684        match("*?", "hell", 0);
    … …  
    687687        match("??*??", "hell", 0);
    688688        nomatch("???*??", "hell", 0);
    689        
     689
    690690        nomatch("", "hell", 0);
    691691        nomatch("?", "hell", 0);
    … …  
    693693        nomatch("???", "hell", 0);
    694694        match("????", "hell", 0);
    695        
     695
    696696        match("*", "h.ello", FNM_PERIOD);
    697697        match("*", "h.ello", FNM_PATHNAME | FNM_PERIOD);

  • uspace/lib/posix/src/pwd.c

    r3061bc1 ra35b458  
    120120        assert(buffer != NULL);
    121121        assert(result != NULL);
    122        
     122
    123123        if (strcmp(name, "user") != 0) {
    124124                *result = NULL;
    125125                return 0;
    126126        }
    127        
     127
    128128        return getpwuid_r(0, pwd, buffer, bufsize, result);
    129129}
    … …  
    161161        assert(buffer != NULL);
    162162        assert(result != NULL);
    163        
     163
    164164        static const char bf[] = { 'u', 's', 'e', 'r', '\0',
    165165            '/', '\0', 'b', 'd', 's', 'h', '\0' };
    166        
     166
    167167        if (uid != 0) {
    168168                *result = NULL;

  • uspace/lib/posix/src/signal.c

    r3061bc1 ra35b458  
    101101                /* Commit suicide. */
    102102                task_kill(task_get_id());
    103                
     103
    104104                /* Should not be reached. */
    105105                abort();
    … …  
    223223{
    224224        assert(set != NULL);
    225        
     225
    226226        return (*set & (1 << signo)) != 0;
    227227}
    … …  
    323323        assert(signo >= 0 && signo <= _TOP_SIGNAL);
    324324        assert(siginfo != NULL);
    325        
     325
    326326        signal_queue_item *item = malloc(sizeof(signal_queue_item));
    327327        link_initialize(&(item->link));
    … …  
    384384        link_t *iterator = _signal_queue.head.next;
    385385        link_t *next;
    386        
     386
    387387        while (iterator != &(_signal_queue).head) {
    388388                next = iterator->next;
    389                
     389
    390390                signal_queue_item *item =
    391391                    list_get_instance(iterator, signal_queue_item, link);
    392                
     392
    393393                if (!sigismember(&_signal_mask, item->signo) &&
    394394                    _signal_actions[item->signo].sa_handler != SIG_HOLD) {
    … …  
    397397                        free(item);
    398398                }
    399                
     399
    400400                iterator = next;
    401401        }
    … …  
    535535                }
    536536        }
    537        
     537
    538538        _dequeue_unblocked_signals();
    539539

  • uspace/lib/posix/src/stdio.c

    r3061bc1 ra35b458  
    277277        size_t sz;
    278278        char buf[4];
    279        
     279
    280280        while (offset < size) {
    281281                sz = 0;
    … …  
    283283                        break;
    284284                }
    285                
     285
    286286                const int fildes = *(int *) fd;
    287287                size_t nwr;
    288288                if (vfs_write(fildes, &posix_pos[fildes], buf, sz, &nwr) != EOK)
    289289                        break;
    290                
     290
    291291                chars++;
    292292                offset += sizeof(wchar_t);
    293293        }
    294        
     294
    295295        return chars;
    296296}
    … …  
    311311                .data = &fildes
    312312        };
    313        
     313
    314314        return printf_core(format, &spec, ap);
    315315}
    … …  
    490490{
    491491        assert(L_tmpnam >= strlen("/tmp/tnXXXXXX"));
    492        
     492
    493493        static char buffer[L_tmpnam + 1];
    494494        if (s == NULL) {
    495495                s = buffer;
    496496        }
    497        
     497
    498498        strcpy(s, "/tmp/tnXXXXXX");
    499499        mktemp(s);
    500        
     500
    501501        if (*s == '\0') {
    502502                /* Errno set by mktemp(). */
    503503                return NULL;
    504504        }
    505        
     505
    506506        return s;
    507507}
    … …  
    518518        /* Sequence number of the filename. */
    519519        static int seq = 0;
    520        
     520
    521521        size_t dir_len = strlen(dir);
    522522        if (dir[dir_len - 1] == '/') {
    523523                dir_len--;
    524524        }
    525        
     525
    526526        size_t pfx_len = strlen(pfx);
    527527        if (pfx_len > 5) {
    528528                pfx_len = 5;
    529529        }
    530        
     530
    531531        char *result = malloc(dir_len + /* slash*/ 1 +
    532532            pfx_len + /* three-digit seq */ 3 + /* .tmp */ 4 + /* nul */ 1);
    533        
     533
    534534        if (result == NULL) {
    535535                errno = ENOMEM;
    536536                return NULL;
    537537        }
    538        
     538
    539539        char *res_ptr = result;
    540540        strncpy(res_ptr, dir, dir_len);
    … …  
    542542        strncpy(res_ptr, pfx, pfx_len);
    543543        res_ptr += pfx_len;
    544        
     544
    545545        for (; seq < 1000; ++seq) {
    546546                snprintf(res_ptr, 8, "%03d.tmp", seq);
    547                
     547
    548548                int orig_errno = errno;
    549549                errno = EOK;
    … …  
    559559                }
    560560        }
    561        
     561
    562562        if (seq == 1000) {
    563563                free(result);
    … …  
    565565                return NULL;
    566566        }
    567        
     567
    568568        return result;
    569569}
    … …  
    585585                return NULL;
    586586        }
    587        
     587
    588588        /* Unlink the created file, so that it's removed on close(). */
    589589        unlink(filename);

  • uspace/lib/posix/src/stdio/scanf.c

    r3061bc1 ra35b458  
    459459{
    460460        assert(modifier);
    461        
     461
    462462        switch (c) {
    463463        case 'S':
    … …  
    880880                        } else if (is_seq_conv(*fmt, &length_mod)) {
    881881                                /* Character sequence conversion. */
    882                                
     882
    883883                                /* Check sanity of optional parts of conversion specifier. */
    884884                                if (length_mod != LMOD_NONE &&
    … …  
    10741074                                        ++converted_cnt;
    10751075                                }
    1076                                
     1076
    10771077                                converting = false;
    10781078                                /* Format string pointer already incremented. */
    … …  
    11021102                                break;
    11031103                        }
    1104                        
     1104
    11051105                } else {
    11061106
    … …  
    11521152                                }
    11531153                        }
    1154                        
     1154
    11551155                }
    11561156

  • uspace/lib/posix/src/stdlib.c

    r3061bc1 ra35b458  
    165165                }
    166166        }
    167        
     167
    168168        return NULL;
    169169}
    … …  
    225225                assert(resolved == NULL);
    226226        #endif
    227        
     227
    228228        if (name == NULL) {
    229229                errno = EINVAL;
    230230                return NULL;
    231231        }
    232        
     232
    233233        // TODO: symlink resolution
    234        
     234
    235235        /* Function absolutize is implemented in libc and declared in vfs.h.
    236236         * No more processing is required as HelenOS doesn't have symlinks
    … …  
    239239         */
    240240        char* absolute = vfs_absolutize(name, NULL);
    241        
     241
    242242        if (absolute == NULL) {
    243243                /* POSIX requires some specific errnos to be set
    … …  
    248248                return NULL;
    249249        }
    250        
     250
    251251        if (resolved == NULL) {
    252252                return absolute;
    … …  
    309309{
    310310        int fd = -1;
    311        
     311
    312312        char *tptr = tmpl + strlen(tmpl) - 6;
    313        
     313
    314314        while (fd < 0) {
    315315                if (*mktemp(tmpl) == '\0') {
    … …  
    317317                        return -1;
    318318                }
    319                
     319
    320320                fd = open(tmpl, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
    321                
     321
    322322                if (fd == -1) {
    323323                        /* Restore template to it's original state. */
    … …  
    325325                }
    326326        }
    327        
     327
    328328        return fd;
    329329}
    … …  
    345345                return tmpl;
    346346        }
    347        
     347
    348348        char *tptr = tmpl + tmpl_len - 6;
    349349        if (strcmp(tptr, "XXXXXX") != 0) {
    … …  
    352352                return tmpl;
    353353        }
    354        
     354
    355355        static int seq = 0;
    356        
     356
    357357        for (; seq < 1000000; ++seq) {
    358358                snprintf(tptr, 7, "%06d", seq);
    359                
     359
    360360                int orig_errno = errno;
    361361                errno = 0;
    … …  
    372372                }
    373373        }
    374        
     374
    375375        if (seq == 10000000) {
    376376                errno = EEXIST;
    … …  
    378378                return tmpl;
    379379        }
    380        
     380
    381381        return tmpl;
    382382}
    … …  
    392392{
    393393        assert(nelem > 0);
    394        
     394
    395395        size_t count;
    396396        load_t *loads = stats_get_load(&count);
    397        
     397
    398398        if (loads == NULL) {
    399399                return -1;
    400400        }
    401        
     401
    402402        if (((size_t) nelem) < count) {
    403403                count = nelem;
    404404        }
    405        
     405
    406406        for (size_t i = 0; i < count; ++i) {
    407407                loadavg[i] = (double) loads[i];
    408408        }
    409        
     409
    410410        free(loads);
    411411        return count;

  • uspace/lib/posix/src/stdlib/strtold.c

    r3061bc1 ra35b458  
    141141                return mant;
    142142        }
    143        
     143
    144144        if (abs(exp) >> (MAX_POW5 + 1) != 0) {
    145145                /* Too large exponent. */
    … …  
    147147                return exp < 0 ? LDBL_MIN : HUGE_VALL;
    148148        }
    149        
     149
    150150        if (exp < 0) {
    151151                exp = abs(exp);
    … …  
    175175                }
    176176        }
    177        
     177
    178178        return mant;
    179179}
    … …  
    191191                return mant;
    192192        }
    193        
     193
    194194        if (exp > LDBL_MAX_EXP || exp < LDBL_MIN_EXP) {
    195195                errno = ERANGE;
    196196                return exp < 0 ? LDBL_MIN : HUGE_VALL;
    197197        }
    198        
     198
    199199        if (exp < 0) {
    200200                exp = abs(exp);
    … …  
    220220                }
    221221        }
    222        
     222
    223223        return mant;
    224224}
    … …  
    242242        assert(sptr != NULL);
    243243        assert (*sptr != NULL);
    244        
     244
    245245        const int DEC_BASE = 10;
    246246        const char DECIMAL_POINT = '.';
    247247        const char EXPONENT_MARK = 'e';
    248        
     248
    249249        const char *str = *sptr;
    250250        long double significand = 0;
    251251        long exponent = 0;
    252        
     252
    253253        /* number of digits parsed so far */
    254254        int parsed_digits = 0;
    255255        bool after_decimal = false;
    256        
     256
    257257        while (isdigit(*str) || (!after_decimal && *str == DECIMAL_POINT)) {
    258258                if (*str == DECIMAL_POINT) {
    … …  
    261261                        continue;
    262262                }
    263                
     263
    264264                if (parsed_digits == 0 && *str == '0') {
    265265                        /* Nothing, just skip leading zeros. */
    … …  
    270270                        exponent++;
    271271                }
    272                
     272
    273273                if (after_decimal) {
    274274                        /* Decrement exponent if we are parsing the fractional part. */
    275275                        exponent--;
    276276                }
    277                
     277
    278278                str++;
    279279        }
    280        
     280
    281281        /* exponent */
    282282        if (tolower(*str) == EXPONENT_MARK) {
    283283                str++;
    284                
     284
    285285                /* Returns MIN/MAX value on error, which is ok. */
    286286                long exp = strtol(str, (char **) &str, DEC_BASE);
    287                
     287
    288288                if (exponent > 0 && exp > LONG_MAX - exponent) {
    289289                        exponent = LONG_MAX;
    … …  
    294294                }
    295295        }
    296        
     296
    297297        *sptr = str;
    298        
     298
    299299        /* Return multiplied by a power of ten. */
    300300        return mul_pow2(mul_pow5(significand, exponent), exponent);
    … …  
    330330{
    331331        assert(sptr != NULL && *sptr != NULL);
    332        
     332
    333333        const int DEC_BASE = 10;
    334334        const int HEX_BASE = 16;
    335335        const char DECIMAL_POINT = '.';
    336336        const char EXPONENT_MARK = 'p';
    337        
     337
    338338        const char *str = *sptr;
    339339        long double significand = 0;
    340340        long exponent = 0;
    341        
     341
    342342        /* number of bits parsed so far */
    343343        int parsed_bits = 0;
    344344        bool after_decimal = false;
    345        
     345
    346346        while (isxdigit(*str) || (!after_decimal && *str == DECIMAL_POINT)) {
    347347                if (*str == DECIMAL_POINT) {
    … …  
    350350                        continue;
    351351                }
    352                
     352
    353353                if (parsed_bits == 0 && *str == '0') {
    354354                        /* Nothing, just skip leading zeros. */
    … …  
    359359                        exponent += 4;
    360360                }
    361                
     361
    362362                if (after_decimal) {
    363363                        exponent -= 4;
    364364                }
    365                
     365
    366366                str++;
    367367        }
    368        
     368
    369369        /* exponent */
    370370        if (tolower(*str) == EXPONENT_MARK) {
    371371                str++;
    372                
     372
    373373                /* Returns MIN/MAX value on error, which is ok. */
    374374                long exp = strtol(str, (char **) &str, DEC_BASE);
    375                
     375
    376376                if (exponent > 0 && exp > LONG_MAX - exponent) {
    377377                        exponent = LONG_MAX;
    … …  
    382382                }
    383383        }
    384        
     384
    385385        *sptr = str;
    386        
     386
    387387        /* Return multiplied by a power of two. */
    388388        return mul_pow2(significand, exponent);
    … …  
    407407{
    408408        assert(nptr != NULL);
    409        
     409
    410410        const int RADIX = '.';
    411        
     411
    412412        /* minus sign */
    413413        bool negative = false;
    414414        /* current position in the string */
    415415        int i = 0;
    416        
     416
    417417        /* skip whitespace */
    418418        while (isspace(nptr[i])) {
    419419                i++;
    420420        }
    421        
     421
    422422        /* parse sign */
    423423        switch (nptr[i]) {
    … …  
    428428                i++;
    429429        }
    430        
     430
    431431        /* check for NaN */
    432432        if (strncasecmp(&nptr[i], "nan", 3) == 0) {
    433433                // FIXME: return NaN
    434434                // TODO: handle the parenthesised case
    435                
     435
    436436                if (endptr != NULL) {
    437437                        *endptr = (char *) nptr;
    … …  
    440440                return 0;
    441441        }
    442        
     442
    443443        /* check for Infinity */
    444444        if (strncasecmp(&nptr[i], "inf", 3) == 0) {
    … …  
    447447                        i += 5;
    448448                }
    449                
     449
    450450                if (endptr != NULL) {
    451451                        *endptr = (char *) &nptr[i];
    … …  
    459459            (nptr[i + 2] == RADIX && isxdigit(nptr[i + 3])))) {
    460460                i += 2;
    461                
     461
    462462                const char *ptr = &nptr[i];
    463463                /* this call sets errno if appropriate. */
    … …  
    468468                return negative ? -result : result;
    469469        }
    470        
     470
    471471        /* check for a decimal number */
    472472        if (isdigit(nptr[i]) || (nptr[i] == RADIX && isdigit(nptr[i + 1]))) {
    … …  
    479479                return negative ? -result : result;
    480480        }
    481        
     481
    482482        /* nothing to parse */
    483483        if (endptr != NULL) {

  • uspace/lib/posix/src/string.c

    r3061bc1 ra35b458  
    6262                ++s1;
    6363        }
    64        
     64
    6565        return (char *) s1;
    6666}
    … …  
    107107        for (size_t i = 0; ; ++i) {
    108108                dest[i] = src[i];
    109                
     109
    110110                if (src[i] == '\0') {
    111111                        /* pointer to the terminating nul character */
    … …  
    113113                }
    114114        }
    115        
     115
    116116        /* unreachable */
    117117        return NULL;
    … …  
    133133        for (size_t i = 0; i < n; ++i) {
    134134                dest[i] = src[i];
    135        
     135
    136136                /* the standard requires that nul characters
    137137                 * are appended to the length of n, in case src is shorter
    … …  
    145145                }
    146146        }
    147        
     147
    148148        return &dest[n];
    149149}
    … …  
    197197        assert(dest != NULL);
    198198        assert(src != NULL);
    199        
     199
    200200        unsigned char* bdest = dest;
    201201        const unsigned char* bsrc = src;
    202        
     202
    203203        for (size_t i = 0; i < n; ++i) {
    204204                bdest[i] = bsrc[i];
    205        
     205
    206206                if (bsrc[i] == (unsigned char) c) {
    207207                        /* pointer to the next byte */
    … …  
    209209                }
    210210        }
    211        
     211
    212212        return NULL;
    213213}
    … …  
    301301{
    302302        assert(mem != NULL);
    303        
     303
    304304        const unsigned char *s = mem;
    305        
     305
    306306        for (size_t i = 0; i < n; ++i) {
    307307                if (s[i] == (unsigned char) c) {
    … …  
    323323{
    324324        assert(s != NULL);
    325        
     325
    326326        char *res = gnu_strchrnul(s, c);
    327327        return (*res == c) ? res : NULL;
    … …  
    339339{
    340340        assert(s != NULL);
    341        
     341
    342342        const char *ptr = strchr(s, '\0');
    343        
     343
    344344        /* the same as in strchr, except it loops in reverse direction */
    345345        while (*ptr != (char) c) {
    … …  
    365365{
    366366        assert(s != NULL);
    367        
     367
    368368        while (*s != c && *s != '\0') {
    369369                s++;
    370370        }
    371        
     371
    372372        return (char *) s;
    373373}
    … …  
    439439        assert(haystack != NULL);
    440440        assert(needle != NULL);
    441        
     441
    442442        /* Special case - needle is an empty string. */
    443443        if (needle[0] == '\0') {
    444444                return (char *) haystack;
    445445        }
    446        
     446
    447447        /* Preprocess needle. */
    448448        size_t nlen = strlen(needle);
    449449        size_t prefix_table[nlen + 1];
    450        
     450
    451451        {
    452452                size_t i = 0;
    453453                ssize_t j = -1;
    454                
     454
    455455                prefix_table[i] = j;
    456                
     456
    457457                while (i < nlen) {
    458458                        while (j >= 0 && needle[i] != needle[j]) {
    … …  
    463463                }
    464464        }
    465        
     465
    466466        /* Search needle using the precomputed table. */
    467467        size_t npos = 0;
    468        
     468
    469469        for (size_t hpos = 0; haystack[hpos] != '\0'; ++hpos) {
    470470                while (npos != 0 && haystack[hpos] != needle[npos]) {
    471471                        npos = prefix_table[npos];
    472472                }
    473                
     473
    474474                if (haystack[hpos] == needle[npos]) {
    475475                        npos++;
    476                        
     476
    477477                        if (npos == nlen) {
    478478                                return (char *) (haystack + hpos - nlen + 1);
    … …  
    480480                }
    481481        }
    482        
     482
    483483        return NULL;
    484484}
    … …  
    604604{
    605605        assert(buf != NULL);
    606        
     606
    607607        char *errstr = strerror(errnum);
    608        
     608
    609609        if (strlen(errstr) + 1 > bufsz) {
    610610                return ERANGE;
    … …  
    625625{
    626626        assert(s != NULL);
    627        
     627
    628628        return (size_t) (strchr(s, '\0') - s);
    629629}
    … …  
    639639{
    640640        assert(s != NULL);
    641        
     641
    642642        for (size_t sz = 0; sz < n; ++sz) {
    643                
     643
    644644                if (s[sz] == '\0') {
    645645                        return sz;
    646646                }
    647647        }
    648        
     648
    649649        return n;
    650650}

  • uspace/lib/posix/src/strings.c

    r3061bc1 ra35b458  
    110110                        return cmp;
    111111                }
    112                
     112
    113113                if (s1[i] == 0) {
    114114                        return 0;
    115115                }
    116116        }
    117        
     117
    118118        return 0;
    119119}

  • uspace/lib/posix/src/sys/mman.c

    r3061bc1 ra35b458  
    4444        if (!start)
    4545                start = AS_AREA_ANY;
    46        
     46
    4747//      if (!((flags & MAP_SHARED) ^ (flags & MAP_PRIVATE)))
    4848//              return MAP_FAILED;
    49        
     49
    5050        if (!(flags & MAP_ANONYMOUS))
    5151                return MAP_FAILED;
    52        
     52
    5353        return as_area_create(start, length, prot, AS_AREA_UNPAGED);
    5454}

  • uspace/lib/posix/src/sys/stat.c

    r3061bc1 ra35b458  
    5252{
    5353        memset(dest, 0, sizeof(struct stat));
    54        
     54
    5555        dest->st_dev = src->service;
    5656        dest->st_ino = src->index;
    57        
     57
    5858        /* HelenOS doesn't support permissions, so we set them all */
    5959        dest->st_mode = S_IRWXU | S_IRWXG | S_IRWXO;
    … …  
    6464                dest->st_mode |= S_IFDIR;
    6565        }
    66        
     66
    6767        dest->st_nlink = src->lnkcnt;
    6868        dest->st_size = src->size;

  • uspace/lib/posix/src/sys/wait.c

    r3061bc1 ra35b458  
    9595        assert(stat_ptr != NULL);
    9696        assert(options == 0 /* None of the options are supported. */);
    97        
     97
    9898        task_exit_t texit;
    9999        int retval;
    100        
     100
    101101        if (failed(task_wait_task_id((task_id_t) pid, &texit, &retval))) {
    102102                /* Unable to retrieve status. */
    103103                return (pid_t) -1;
    104104        }
    105        
     105
    106106        if (texit == TASK_EXIT_NORMAL) {
    107107                // FIXME: relies on application not returning this value
    … …  
    112112                *stat_ptr = INT_MIN;
    113113        }
    114        
     114
    115115        return pid;
    116116}
Note: See TracChangeset for help on using the changeset viewer.