Changeset 8565a42 in mainline for uspace/lib/posix


Ignore:
Timestamp:
2018-03-02T20:34:50Z (8 years ago)
Author:
GitHub <noreply@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a1a81f69, d5e5fd1
Parents:
3061bc1 (diff), 34e1206 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:34:50)
git-committer:
GitHub <noreply@…> (2018-03-02 20:34:50)
Message:

Remove all trailing whitespace, everywhere.

See individual commit messages for details.

Location:
uspace/lib/posix
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/posix/Makefile

    r3061bc1 r8565a42  
    165165        mkdir -p $(EXPORT_DIR)/include.new/libclui
    166166        cp -L ../clui/tinput.h $(EXPORT_DIR)/include.new/libclui
    167        
     167
    168168        find "$(EXPORT_DIR)/include.new/libc" "$(EXPORT_DIR)/include.new/libclui" -name '*.h' -exec sed \
    169169                -e 's:#include <:#include <libc/:' \
    … …  
    176176                -e 's:#include <posix/:#include <:' \
    177177                -i {} \;
    178        
     178
    179179        rm -rf $(EXPORT_DIR)/include
    180180        mv $(EXPORT_DIR)/include.new $(EXPORT_DIR)/include

  • uspace/lib/posix/include/posix/signal.h

    r3061bc1 r8565a42  
    129129        SIGINT,
    130130        SIGTERM,
    131        
     131
    132132        /* Child Signal */
    133133        SIGCHLD,
    134        
     134
    135135        /* User signals */
    136136        SIGUSR1,
    … …  
    177177        SIGTTIN,
    178178        SIGTTOU,
    179        
     179
    180180        _TOP_SIGNAL = SIGTTOU
    181181};

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

    r3061bc1 r8565a42  
    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 r8565a42  
    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 r8565a42  
    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 r8565a42  
    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 r8565a42  
    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 r8565a42  
    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 r8565a42  
    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 r8565a42  
    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 r8565a42  
    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 r8565a42  
    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 r8565a42  
    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 r8565a42  
    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 r8565a42  
    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.