Changes in / [eccd20e6:df0956ee] in mainline


Ignore:
Location:
uspace/lib/posix
Files:
47 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/posix/Makefile

    reccd20e6 rdf0956ee  
    6363$(INCLUDE_LIBC): ../c/include
    6464        ln -s -f -n $^ $@
     65

  • uspace/lib/posix/assert.h

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Program assertion.
     32/** @file
    3333 */
    3434
    … …  
    5252/** @}
    5353 */
     54

  • uspace/lib/posix/ctype.c

    reccd20e6 rdf0956ee  
    3131 * @{
    3232 */
    33 /** @file Character classification.
     33/** @file
    3434 */
    3535
    … …  
    4343 * Checks whether character is a hexadecimal digit.
    4444 *
    45  * @param c Character to inspect.
    46  * @return Non-zero if character match the definition, zero otherwise.
     45 * @param c
     46 * @return
    4747 */
    4848int posix_isxdigit(int c)
    … …  
    5656 * Checks whether character is a word separator.
    5757 *
    58  * @param c Character to inspect.
    59  * @return Non-zero if character match the definition, zero otherwise.
     58 * @param c
     59 * @return
    6060 */
    6161int posix_isblank(int c)
    … …  
    6767 * Checks whether character is a control character.
    6868 *
    69  * @param c Character to inspect.
    70  * @return Non-zero if character match the definition, zero otherwise.
     69 * @param c
     70 * @return
    7171 */
    7272int posix_iscntrl(int c)
    … …  
    7878 * Checks whether character is any printing character except space.
    7979 *
    80  * @param c Character to inspect.
    81  * @return Non-zero if character match the definition, zero otherwise.
     80 * @param c
     81 * @return
    8282 */
    8383int posix_isgraph(int c)
    … …  
    8989 * Checks whether character is a printing character.
    9090 *
    91  * @param c Character to inspect.
    92  * @return Non-zero if character match the definition, zero otherwise.
     91 * @param c
     92 * @return
    9393 */
    9494int posix_isprint(int c)
    … …  
    100100 * Checks whether character is a punctuation.
    101101 *
    102  * @param c Character to inspect.
    103  * @return Non-zero if character match the definition, zero otherwise.
     102 * @param c
     103 * @return
    104104 */
    105105int posix_ispunct(int c)
    106106{
    107         return !isspace(c) && !isalnum(c) && posix_isprint(c);
     107        return !isspace(c) && !isalnum(c);
    108108}
    109109
    … …  
    111111 * Checks whether character is ASCII. (obsolete)
    112112 *
    113  * @param c Character to inspect.
    114  * @return Non-zero if character match the definition, zero otherwise.
     113 * @param c
     114 * @return
    115115 */
    116116extern int posix_isascii(int c)
    … …  
    122122 * Converts argument to a 7-bit ASCII character. (obsolete)
    123123 *
    124  * @param c Character to convert.
    125  * @return Coverted character.
     124 * @param c
     125 * @return
    126126 */
    127127extern int posix_toascii(int c)

  • uspace/lib/posix/ctype.h

    reccd20e6 rdf0956ee  
    3131 * @{
    3232 */
    33 /** @file Character classification.
     33/** @file
    3434 */
    3535

  • uspace/lib/posix/errno.c

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file System error numbers.
     32/** @file
    3333 */
    3434
    … …  
    5151/** @}
    5252 */
     53

  • uspace/lib/posix/errno.h

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file System error numbers.
     32/** @file
    3333 */
    3434
    … …  
    325325/** @}
    326326 */
     327

  • uspace/lib/posix/fcntl.c

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file File control.
     32/** @file
    3333 */
    3434

  • uspace/lib/posix/fcntl.h

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file File control.
     32/** @file
    3333 */
    3434

  • uspace/lib/posix/float.h

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Floating type support.
     32/** @file
    3333 */
    3434

  • uspace/lib/posix/fnmatch.c

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Filename-matching.
     32/** @file
    3333 */
    3434
    … …  
    4545#include "internal/common.h"
    4646#include "fnmatch.h"
    47 
    48 // TODO: documentation
    4947
    5048#define INVALID_PATTERN -1
    … …  
    171169};
    172170
    173 /**
    174  *
    175  * @param key
    176  * @param elem
    177  * @return
    178  */
    179171static int _class_compare(const void *key, const void *elem)
    180172{
    … …  
    183175}
    184176
    185 /**
    186  *
    187  * @param cname
    188  * @param c
    189  * @return
    190  */
    191177static bool _is_in_class (const char *cname, int c)
    192178{
    … …  
    205191}
    206192
    207 /**
    208  *
    209  * @param pattern
    210  * @param str
    211  * @param flags
    212  * @return
    213  */
    214193static int _match_char_class(const char **pattern, const char *str, int flags)
    215194{
    … …  
    225204/************** END CHARACTER CLASSES ****************/
    226205
    227 /**
    228  *
    229  * @param pattern
    230  * @param flags
    231  * @return
    232  */
    233206static _coll_elm_t _next_coll_elm(const char **pattern, int flags)
    234207{
    … …  
    267240
    268241/**
    269  *
    270  * @param pattern
    271  * @param str
    272  * @param flags
    273  * @return
     242 *
    274243 */
    275244static int _match_bracket_expr(const char **pattern, const char *str, int flags)
    … …  
    358327
    359328/**
    360  *
    361  * @param pattern
    362  * @param string
    363  * @param flags
    364  * @return
     329 *
    365330 */
    366331static bool _partial_match(const char **pattern, const char **string, int flags)
    … …  
    456421}
    457422
    458 /**
    459  *
    460  * @param pattern
    461  * @param string
    462  * @param flags
    463  * @return
    464  */
    465423static bool _full_match(const char *pattern, const char *string, int flags)
    466424{
    … …  
    518476}
    519477
    520 /**
    521  *
    522  * @param s
    523  * @return
    524  */
    525478static char *_casefold(const char *s)
    526479{
    … …  
    553506
    554507        if ((flags & FNM_CASEFOLD) != 0) {
    555                 if (pattern) {
    556                         free((char *) pattern);
    557                 }
    558                 if (string) {
    559                         free((char *) string);
    560                 }
     508                free((char *) pattern);
     509                free((char *) string);
    561510        }
    562511
    … …  
    655604/** @}
    656605 */
     606

  • uspace/lib/posix/fnmatch.h

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Filename-matching.
     32/** @file
    3333 */
    3434
    … …  
    3636#define POSIX_FNMATCH_H_
    3737
    38 /* Error Values */
     38/* Error Values. */
    3939#undef FNM_NOMATCH
    4040#define FNM_NOMATCH 1
    … …  
    6666/** @}
    6767 */
     68

  • uspace/lib/posix/internal/common.h

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Helper definitions common for all libposix files.
     32/** @file
    3333 */
    3434

  • uspace/lib/posix/inttypes.h

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Fixed size integer types.
     32/** @file
    3333 */
    3434
    … …  
    3939#include "libc/inttypes.h"
    4040
    41 extern posix_intmax_t posix_strtoimax(const char *restrict nptr,
    42     char **restrict endptr, int base);
    43 extern posix_uintmax_t posix_strtoumax(const char *restrict nptr,
    44     char **restrict endptr, int base);
    45 
    46 #ifndef LIBPOSIX_INTERNAL
    47         #define strtoimax posix_strtoimax
    48         #define strtoumax posix_strtoumax
    49 #endif
    50 
    5141#endif /* POSIX_INTTYPES_H_ */
    5242

  • uspace/lib/posix/iso646.h

    reccd20e6 rdf0956ee  
    1 /*
    2  * Copyright (c) 2011 Jiri Zarevucky
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  *
    9  * - Redistributions of source code must retain the above copyright
    10  *   notice, this list of conditions and the following disclaimer.
    11  * - Redistributions in binary form must reproduce the above copyright
    12  *   notice, this list of conditions and the following disclaimer in the
    13  *   documentation and/or other materials provided with the distribution.
    14  * - The name of the author may not be used to endorse or promote products
    15  *   derived from this software without specific prior written permission.
    16  *
    17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
    18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
    19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
    20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
    21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
    22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
    26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    27  */
    281
    292/** @addtogroup libposix
    303 * @{
    314 */
    32 /** @file Alternative spellings.
     5/** @file
    336 */
    347
    … …  
    5225/** @}
    5326 */
     27

  • uspace/lib/posix/limits.h

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Implementation-defined limit constants.
     32/** @file
    3333 */
    3434

  • uspace/lib/posix/locale.c

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Locale-specific definitions.
     32/** @file
    3333 */
    3434
    … …  
    4141#include "limits.h"
    4242#include "string.h"
    43 
    44 // TODO: documentation
    4543
    4644struct __posix_locale {
    … …  
    7573};
    7674
    77 /**
    78  *
    79  * @param category
    80  * @param locale
    81  * @return
    82  */
    8375char *posix_setlocale(int category, const char *locale)
    8476{
    … …  
    9183}
    9284
    93 /**
    94  *
    95  * @return
    96  */
    9785struct posix_lconv *posix_localeconv(void)
    9886{
    … …  
    10189}
    10290
    103 /**
    104  *
    105  * @param locobj
    106  * @return
    107  */
    10891posix_locale_t posix_duplocale(posix_locale_t locobj)
    10992{
    … …  
    121104}
    122105
    123 /**
    124  *
    125  * @param locobj
    126  */
    127106void posix_freelocale(posix_locale_t locobj)
    128107{
    129         if (locobj) {
    130                 free(locobj);
    131         }
     108        free(locobj);
    132109}
    133110
    134 /**
    135  *
    136  * @param category_mask
    137  * @param locale
    138  * @param base
    139  * @return
    140  */
    141111posix_locale_t posix_newlocale(int category_mask, const char *locale,
    142112    posix_locale_t base)
    … …  
    159129}
    160130
    161 /**
    162  *
    163  * @param newloc
    164  * @return
    165  */
    166 posix_locale_t posix_uselocale(posix_locale_t newloc)
     131posix_locale_t posix_uselocale (posix_locale_t newloc)
    167132{
    168133        // TODO

  • uspace/lib/posix/locale.h

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Locale-specific definitions.
     32/** @file
    3333 */
    3434
    3535#ifndef POSIX_LOCALE_H_
    3636#define POSIX_LOCALE_H_
    37 
    38 // TODO: documentation
    3937
    4038#ifndef NULL
    … …  
    8583
    8684struct posix_lconv {
    87         char *currency_symbol;
    88         char *decimal_point;
    89         char  frac_digits;
    90         char *grouping;
    91         char *int_curr_symbol;
    92         char  int_frac_digits;
    93         char  int_n_cs_precedes;
    94         char  int_n_sep_by_space;
    95         char  int_n_sign_posn;
    96         char  int_p_cs_precedes;
    97         char  int_p_sep_by_space;
    98         char  int_p_sign_posn;
    99         char *mon_decimal_point;
    100         char *mon_grouping;
    101         char *mon_thousands_sep;
    102         char *negative_sign;
    103         char  n_cs_precedes;
    104         char  n_sep_by_space;
    105         char  n_sign_posn;
    106         char *positive_sign;
    107         char  p_cs_precedes;
    108         char  p_sep_by_space;
    109         char  p_sign_posn;
    110         char *thousands_sep;
     85        char    *currency_symbol;
     86        char    *decimal_point;
     87        char     frac_digits;
     88        char    *grouping;
     89        char    *int_curr_symbol;
     90        char     int_frac_digits;
     91        char     int_n_cs_precedes;
     92        char     int_n_sep_by_space;
     93        char     int_n_sign_posn;
     94        char     int_p_cs_precedes;
     95        char     int_p_sep_by_space;
     96        char     int_p_sign_posn;
     97        char    *mon_decimal_point;
     98        char    *mon_grouping;
     99        char    *mon_thousands_sep;
     100        char    *negative_sign;
     101        char     n_cs_precedes;
     102        char     n_sep_by_space;
     103        char     n_sign_posn;
     104        char    *positive_sign;
     105        char     p_cs_precedes;
     106        char     p_sep_by_space;
     107        char     p_sign_posn;
     108        char    *thousands_sep;
    111109};
    112110
    … …  
    119117extern posix_locale_t posix_newlocale(int category_mask, const char *locale,
    120118    posix_locale_t base);
    121 extern posix_locale_t posix_uselocale(posix_locale_t newloc);
     119extern posix_locale_t posix_uselocale (posix_locale_t newloc);
    122120
    123121#ifndef LIBPOSIX_INTERNAL
    … …  
    133131#endif
    134132
     133
    135134#endif /* POSIX_LOCALE_H_ */
    136135

  • uspace/lib/posix/math.c

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Mathematical operations.
     32/** @file
    3333 */
    3434

  • uspace/lib/posix/math.h

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Mathematical operations.
     32/** @file
    3333 */
    3434

  • uspace/lib/posix/pwd.c

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Password handling.
     32/** @file
    3333 */
    3434
    3535#define LIBPOSIX_INTERNAL
    36 
    3736#include "pwd.h"
    3837#include "string.h"
    3938#include "errno.h"
    4039
    41 // TODO: documentation
    4240
    4341static bool entry_read = false;
    … …  
    5553 * Since HelenOS doesn't have user accounts, this always returns
    5654 * the same made-up entry.
    57  *
    58  * @return
    5955 */
    6056struct posix_passwd *posix_getpwent(void)
    … …  
    182178/** @}
    183179 */
     180

  • uspace/lib/posix/pwd.h

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Password handling.
     32/** @file
    3333 */
    3434
    3535#ifndef POSIX_PWD_H_
    3636#define POSIX_PWD_H_
    37 
    38 // TODO: documentation
    3937
    4038#include "sys/types.h"
    … …  
    7876/** @}
    7977 */
     78

  • uspace/lib/posix/signal.c

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Signal handling.
     32/** @file
    3333 */
    3434
    … …  
    4545#include "libc/task.h"
    4646
    47 // TODO: documentation
    48 
    4947/* Used to serialize signal handling. */
    5048static FIBRIL_MUTEX_INITIALIZE(_signal_mutex);
    … …  
    6563};
    6664
    67 /**
    68  *
    69  * @param signo
    70  */
    7165void __posix_default_signal_handler(int signo)
    7266{
    … …  
    124118}
    125119
    126 /**
    127  *
    128  * @param signo
    129  */
    130120void __posix_hold_signal_handler(int signo)
    131121{
    … …  
    133123}
    134124
    135 /**
    136  *
    137  * @param signo
    138  */
    139125void __posix_ignore_signal_handler(int signo)
    140126{
    … …  
    142128}
    143129
    144 /**
    145  *
    146  * @param set
    147  * @return
    148  */
     130
    149131int posix_sigemptyset(posix_sigset_t *set)
    150132{
    … …  
    155137}
    156138
    157 /**
    158  *
    159  * @param set
    160  * @return
    161  */
    162139int posix_sigfillset(posix_sigset_t *set)
    163140{
    … …  
    168145}
    169146
    170 /**
    171  *
    172  * @param set
    173  * @param signo
    174  * @return
    175  */
    176147int posix_sigaddset(posix_sigset_t *set, int signo)
    177148{
    … …  
    182153}
    183154
    184 /**
    185  *
    186  * @param set
    187  * @param signo
    188  * @return
    189  */
    190155int posix_sigdelset(posix_sigset_t *set, int signo)
    191156{
    … …  
    196161}
    197162
    198 /**
    199  *
    200  * @param set
    201  * @param signo
    202  * @return
    203  */
    204163int posix_sigismember(const posix_sigset_t *set, int signo)
    205164{
    … …  
    209168}
    210169
    211 /**
    212  *
    213  * @param sig
    214  * @param act
    215  * @param oact
    216  */
    217170static void _sigaction_unsafe(int sig, const struct posix_sigaction *restrict act,
    218171    struct posix_sigaction *restrict oact)
    … …  
    229182}
    230183
    231 /**
    232  *
    233  * @param sig
    234  * @param act
    235  * @param oact
    236  * @return
    237  */
    238184int posix_sigaction(int sig, const struct posix_sigaction *restrict act,
    239185    struct posix_sigaction *restrict oact)
    … …  
    260206}
    261207
    262 /**
    263  *
    264  * @param sig
    265  * @param func
    266  * @return
    267  */
    268208void (*posix_signal(int sig, void (*func)(int)))(int)
    269209{
    … …  
    282222}
    283223
    284 /**
    285  *
    286  * @param signo
    287  * @param siginfo
    288  * @return
    289  */
    290224static int _raise_sigaction(int signo, posix_siginfo_t *siginfo)
    291225{
    … …  
    325259}
    326260
    327 /**
    328  *
    329  * @param sig
    330  * @return
    331  */
    332261int posix_raise(int sig)
    333262{
    … …  
    344273}
    345274
    346 /**
    347  *
    348  * @param pid
    349  * @param signo
    350  * @return
    351  */
    352275int posix_kill(posix_pid_t pid, int signo)
    353276{
    … …  
    380303}
    381304
    382 /**
    383  *
    384  * @param pid
    385  * @param sig
    386  * @return
    387  */
    388305int posix_killpg(posix_pid_t pid, int sig)
    389306{
    … …  
    392309}
    393310
    394 /**
    395  *
    396  * @param pinfo
    397  * @param message
    398  */
    399311void posix_psiginfo(const posix_siginfo_t *pinfo, const char *message)
    400312{
    … …  
    404316}
    405317
    406 /**
    407  *
    408  * @param signum
    409  * @param message
    410  */
    411318void posix_psignal(int signum, const char *message)
    412319{
    … …  
    419326}
    420327
    421 /**
    422  *
    423  * @param how
    424  * @param set
    425  * @param oset
    426  * @return
    427  */
    428328int posix_thread_sigmask(int how, const posix_sigset_t *restrict set,
    429329    posix_sigset_t *restrict oset)
    … …  
    458358}
    459359
    460 /**
    461  *
    462  * @param how
    463  * @param set
    464  * @param oset
    465  * @return
    466  */
    467360int posix_sigprocmask(int how, const posix_sigset_t *restrict set,
    468361    posix_sigset_t *restrict oset)
    … …  
    478371/** @}
    479372 */
     373

  • uspace/lib/posix/signal.h

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Signal handling.
     32/** @file
    3333 */
    3434
    3535#ifndef POSIX_SIGNAL_H_
    3636#define POSIX_SIGNAL_H_
    37 
    38 // TODO: documentation
    3937
    4038#include "libc/errno.h"
    … …  
    109107        posix_mcontext_t uc_mcontext;
    110108} posix_ucontext_t;
     109
    111110
    112111/* Values of posix_sigevent::sigev_notify */
    … …  
    155154#define SIGSTKSZ 0
    156155
    157 /* Full POSIX set */
     156/* full POSIX set */
    158157enum {
    159158        /* Termination Signals */
    … …  
    215214
    216215/* Values for sigaction field si_code. */
     216
    217217enum {
    218218        SI_USER,
    … …  
    287287                #define sigevent posix_sigevent
    288288        #endif
     289        #define sigaction posix_sigaction
    289290        #define mcontext_t posix_mcontext_t
    290291        #define ucontext_t posix_ucontext_t
    291292        #define stack_t posix_stack_t
    292293        #define siginfo_t posix_siginfo_t
    293 
    294         #define sigaction posix_sigaction
    295294
    296295        #define signal posix_signal

  • uspace/lib/posix/stdbool.h

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Boolean type and values.
     32/** @file
    3333 */
    3434
    … …  
    5050
    5151#endif /* POSIX_STDBOOL_H_ */
     52

  • uspace/lib/posix/stddef.h

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Standard type definitions.
     32/** @file
    3333 */
    3434

  • uspace/lib/posix/stdint.h

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Integer types.
     32/** @file
    3333 */
    3434
    … …  
    8888#define AOFF64_MIN  UINT64_MIN
    8989
    90 #undef INTMAX_MIN
    91 #undef INTMAX_MAX
    92 #define INTMAX_MIN INT64_MIN
    93 #define INTMAX_MAX INT64_MAX
    94 
    95 #undef UINTMAX_MIN
    96 #undef UINTMAX_MAX
    97 #define UINTMAX_MIN UINT64_MIN
    98 #define UINTMAX_MAX UINT64_MAX
    99 
    10090#include "libc/sys/types.h"
    10191

  • uspace/lib/posix/stdio.c

    reccd20e6 rdf0956ee  
    3131 * @{
    3232 */
    33 /** @file Standard buffered input/output.
     33/** @file
    3434 */
    3535
    … …  
    355355{
    356356        off64_t ret = ftell(stream);
    357         if (ret != -1) {
    358                 pos->offset = ret;
    359                 return 0;
    360         } else {
    361                 return -1;
    362         }
     357        if (ret == -1) {
     358                return errno;
     359        }
     360        pos->offset = ret;
     361        return 0;
    363362}
    364363

  • uspace/lib/posix/stdio.h

    reccd20e6 rdf0956ee  
    3131 * @{
    3232 */
    33 /** @file Standard buffered input/output.
     33/** @file
    3434 */
    3535

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

    reccd20e6 rdf0956ee  
    303303        self->fetched = 0;
    304304        self->cursor = NULL;
    305         if (self->window) {
    306                 free(self->window);
    307                 self->window = NULL;
    308         }
     305        free(self->window);
     306        self->window = NULL;
    309307        self->window_size = 0;
    310308        self->state = _PROV_CONSTRUCTED;
    … …  
    655653                                /* Update the cursor so it can be returned to the provider. */
    656654                                cur_borrowed += cur_updated - cur_limited;
    657                                 if (width != -1 && cur_limited != NULL) {
     655                                if (width != -1) {
    658656                                        /* Deallocate duplicated part of the cursor view. */
    659657                                        free(cur_limited);
    … …  
    835833                                /* Update the cursor so it can be returned to the provider. */
    836834                                cur_borrowed += cur_updated - cur_limited;
    837                                 if (width != -1 && cur_limited != NULL) {
     835                                if (width != -1) {
    838836                                        /* Deallocate duplicated part of the cursor view. */
    839837                                        free(cur_limited);

  • uspace/lib/posix/stdlib.c

    reccd20e6 rdf0956ee  
    3131 * @{
    3232 */
    33 /** @file Standard library definitions.
     33/** @file
    3434 */
    3535
    … …  
    4040
    4141#include "errno.h"
    42 #include "limits.h"
    4342
    4443#include "libc/sort.h"
    … …  
    6059
    6160/**
    62  * Integer absolute value.
    6361 *
    6462 * @param i Input value.
    … …  
    7169
    7270/**
    73  * Long integer absolute value.
    7471 *
    7572 * @param i Input value.
    … …  
    8279
    8380/**
    84  * Long long integer absolute value.
    8581 *
    8682 * @param i Input value.
    … …  
    9288}
    9389
    94 /**
    95  * Compute the quotient and remainder of an integer division.
    96  *
    97  * @param numer Numerator.
    98  * @param denom Denominator.
    99  * @return Quotient and remainder packed into structure.
    100  */
    10190posix_div_t posix_div(int numer, int denom)
    10291{
    … …  
    10493}
    10594
    106 /**
    107  * Compute the quotient and remainder of a long integer division.
    108  *
    109  * @param numer Numerator.
    110  * @param denom Denominator.
    111  * @return Quotient and remainder packed into structure.
    112  */
    11395posix_ldiv_t posix_ldiv(long numer, long denom)
    11496{
    … …  
    11698}
    11799
    118 /**
    119  * Compute the quotient and remainder of a long long integer division.
    120  *
    121  * @param numer Numerator.
    122  * @param denom Denominator.
    123  * @return Quotient and remainder packed into structure.
    124  */
    125100posix_lldiv_t posix_lldiv(long long numer, long long denom)
    126101{
    … …  
    134109 * @param elem2 Second element to compare.
    135110 * @param compare Comparison function without userdata parameter.
     111 *
    136112 * @return Relative ordering of the elements.
    137113 */
    … …  
    139115{
    140116        int (*compare)(const void *, const void *) = userdata;
    141         int ret = compare(elem1, elem2);
    142        
    143         /* Native qsort internals expect this. */
    144         if (ret < 0) {
    145                 return -1;
    146         } else if (ret > 0) {
    147                 return 1;
    148         } else {
    149                 return 0;
    150         }
     117        return compare(elem1, elem2);
    151118}
    152119
    … …  
    154121 * Array sorting utilizing the quicksort algorithm.
    155122 *
    156  * @param array Array of elements to sort.
    157  * @param count Number of elements in the array.
    158  * @param size Width of each element.
    159  * @param compare Decides relative ordering of two elements.
     123 * @param array
     124 * @param count
     125 * @param size
     126 * @param compare
    160127 */
    161128void posix_qsort(void *array, size_t count, size_t size,
    … …  
    204171/**
    205172 * Retrieve a value of the given environment variable.
    206  *
    207173 * Since HelenOS doesn't support env variables at the moment,
    208174 * this function always returns NULL.
    209175 *
    210  * @param name Name of the variable.
    211  * @return Value of the variable or NULL if such variable does not exist.
     176 * @param name
     177 * @return Always NULL.
    212178 */
    213179char *posix_getenv(const char *name)
    … …  
    229195
    230196/**
    231  * Issue a command.
    232  *
    233  * @param string String to be passed to a command interpreter or NULL.
    234  * @return Termination status of the command if the command is not NULL,
    235  *     otherwise indicate whether there is a command interpreter (non-zero)
    236  *     or not (zero).
     197 *
     198 * @param string String to be passed to a command interpreter.
     199 * @return
    237200 */
    238201int posix_system(const char *string) {
    … …  
    242205
    243206/**
    244  * Resolve absolute pathname.
    245  *
    246  * @param name Pathname to be resolved.
    247  * @param resolved Either buffer for the resolved absolute pathname or NULL.
    248  * @return On success, either resolved (if it was not NULL) or pointer to the
    249  *     newly allocated buffer containing the absolute pathname (if resolved was
    250  *     NULL). Otherwise NULL.
    251  *
    252  */
    253 char *posix_realpath(const char *restrict name, char *restrict resolved)
     207 *
     208 * @param name
     209 * @param resolved
     210 * @return
     211 */
     212char *posix_realpath(const char *name, char *resolved)
    254213{
    255214        #ifndef PATH_MAX
    … …  
    295254 * its native representation. See posix_strtold().
    296255 *
    297  * @param nptr String representation of a floating-point number.
    298  * @return Double-precision number resulting from the string conversion.
     256 * @param nptr
     257 * @return
    299258 */
    300259double posix_atof(const char *nptr)
    … …  
    307266 * its native representation. See posix_strtold().
    308267 *
    309  * @param nptr String representation of a floating-point number.
    310  * @param endptr Pointer to the final part of the string which
    311  *     was not used for conversion.
    312  * @return Single-precision number resulting from the string conversion.
     268 * @param nptr
     269 * @param endptr
     270 * @return
    313271 */
    314272float posix_strtof(const char *restrict nptr, char **restrict endptr)
    … …  
    321279 * its native representation. See posix_strtold().
    322280 *
    323  * @param nptr String representation of a floating-point number.
    324  * @param endptr Pointer to the final part of the string which
    325  *     was not used for conversion.
    326  * @return Double-precision number resulting from the string conversion.
     281 * @param nptr
     282 * @param endptr
     283 * @return
    327284 */
    328285double posix_strtod(const char *restrict nptr, char **restrict endptr)
    … …  
    332289
    333290/**
    334  * Allocate memory chunk.
    335  *
    336  * @param size Size of the chunk to allocate.
    337  * @return Either pointer to the allocated chunk or NULL if not possible.
     291 *
     292 * @param size
     293 * @return
    338294 */
    339295void *posix_malloc(size_t size)
    … …  
    343299
    344300/**
    345  * Allocate memory for an array of elements.
    346  *
    347  * @param nelem Number of elements in the array.
    348  * @param elsize Size of each element.
    349  * @return Either pointer to the allocated array or NULL if not possible.
     301 *
     302 * @param nelem
     303 * @param elsize
     304 * @return
    350305 */
    351306void *posix_calloc(size_t nelem, size_t elsize)
    … …  
    355310
    356311/**
    357  * Reallocate memory chunk to a new size.
    358  *
    359  * @param ptr Memory chunk to reallocate. Might be NULL.
    360  * @param size Size of the reallocated chunk. Might be zero.
    361  * @return Either NULL or the pointer to the newly reallocated chunk.
     312 *
     313 * @param ptr
     314 * @param size
     315 * @return
    362316 */
    363317void *posix_realloc(void *ptr, size_t size)
    364318{
    365         if (ptr != NULL && size == 0) {
    366                 /* Native realloc does not handle this special case. */
    367                 free(ptr);
    368                 return NULL;
    369         } else {
    370                 return realloc(ptr, size);
    371         }
    372 }
    373 
    374 /**
    375  * Free allocated memory chunk.
    376  *
    377  * @param ptr Memory chunk to be freed.
     319        return realloc(ptr, size);
     320}
     321
     322/**
     323 *
     324 * @param ptr
    378325 */
    379326void posix_free(void *ptr)
    … …  
    396343
    397344/**
    398  * Get system load average statistics.
    399  *
    400  * Not supported. Always returns -1.
    401  *
    402  * @param loadavg Array where the load averages shall be placed.
    403  * @param nelem Maximum number of elements to be placed into the array.
    404  * @return Number of elements placed into the array on success, -1 otherwise.
     345 * Should read system load statistics. Not supported. Always returns -1.
     346 *
     347 * @param loadavg
     348 * @param nelem
     349 * @return
    405350 */
    406351int bsd_getloadavg(double loadavg[], int nelem)

  • uspace/lib/posix/stdlib.h

    reccd20e6 rdf0956ee  
    3131 * @{
    3232 */
    33 /** @file Standard library definitions.
     33/** @file
    3434 */
    3535
    … …  
    5656extern long long posix_llabs(long long i);
    5757
    58 /* Integer Division */
     58/* Integer division */
    5959
    6060typedef struct {
    … …  
    8080    size_t nmemb, size_t size, int (*compar)(const void *, const void *));
    8181
     82
    8283/* Environment Access */
    8384extern char *posix_getenv(const char *name);
    8485extern int posix_putenv(char *string);
     86
    8587extern int posix_system(const char *string);
     88
    8689
    8790/* Symbolic Links */
    … …  
    98101extern long int posix_atol(const char *nptr);
    99102extern long long int posix_atoll(const char *nptr);
     103
    100104extern long int posix_strtol(const char *restrict nptr,
    101105    char **restrict endptr, int base);
    … …  
    106110extern unsigned long long int posix_strtoull(
    107111    const char *restrict nptr, char **restrict endptr, int base);
     112
    108113
    109114/* Memory Allocation */

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

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Backend for integer conversions.
     32/** @file
    3333 */
    3434
    … …  
    3838#include "../stdlib.h"
    3939
     40#include "../limits.h"
    4041#include "../ctype.h"
    4142#include "../errno.h"
    42 #include "../inttypes.h"
    43 #include "../limits.h"
    44 
    45 #define intmax_t posix_intmax_t
    46 #define uintmax_t posix_uintmax_t
    47 
    48 /**
    49  * Decides whether a digit belongs to a particular base.
    50  *
    51  * @param c Character representation of the digit.
    52  * @param base Base against which the digit shall be tested.
    53  * @return True if the digit belongs to the base, false otherwise.
    54  */
     43
     44// TODO: documentation
     45
    5546static inline bool is_digit_in_base(int c, int base)
    5647{
    … …  
    6354}
    6455
    65 /**
    66  * Derive a digit from its character representation.
    67  *
    68  * @param c Character representation of the digit.
    69  * @return Digit value represented by an integer.
    70  */
    71 static inline int digit_value(int c)
     56static inline int get_digit_in_base(int c, int base)
    7257{
    7358        if (c <= '9') {
    … …  
    7863}
    7964
    80 /**
    81  * Generic function for parsing an integer from it's string representation.
    82  * Different variants differ in lower and upper bounds.
    83  * The parsed string returned by this function is always positive, sign
    84  * information is provided via a dedicated parameter.
    85  *
    86  * @param nptr Input string.
    87  * @param endptr If non-NULL, *endptr is set to the position of the first
    88  *     unrecognized character. If no digit has been parsed, value of
    89  *     nptr is stored there (regardless of any skipped characters at the
    90  *     beginning).
    91  * @param base Expected base of the string representation. If 0, base is
    92  *    determined to be decimal, octal or hexadecimal using the same rules
    93  *    as C syntax. Otherwise, value must be between 2 and 36, inclusive.
    94  * @param min_value Lower bound for the resulting conversion.
    95  * @param max_value Upper bound for the resulting conversion.
    96  * @param out_negative Either NULL for unsigned conversion or a pointer to the
    97  *     bool variable into which shall be placed the negativity of the resulting
    98  *     converted value.
    99  * @return The absolute value of the parsed value, or the closest in-range value
    100  *     if the parsed value is out of range. If the input is invalid, zero is
    101  *     returned and errno is set to EINVAL.
    102  */
    103 static inline uintmax_t internal_strtol(
     65static inline unsigned long long internal_strtol(
    10466    const char *restrict nptr, char **restrict endptr, int base,
    105     const intmax_t min_value, const uintmax_t max_value,
     67    const long long min_value, const unsigned long long max_value,
    10668    bool *restrict out_negative)
    10769{
    … …  
    11678        }
    11779       
    118         /* The maximal absolute value that can be returned in this run.
    119          * Depends on sign.
    120          */
    121         uintmax_t real_max_value = max_value;
     80        unsigned long long real_max_value = max_value;
    12281       
    12382        /* Current index in the input string. */
    124         size_t i = 0;
     83        int i = 0;
    12584        bool negative = false;
    12685       
    … …  
    13493        case '-':
    13594                negative = true;
    136                
    137                 /* The strange computation is are there to avoid a corner case
    138                  * where -min_value can't be represented in intmax_t.
    139                  * (I'm not exactly sure what the semantics are in such a
    140                  *  case, but this should be safe for any case.)
    141                  */
    142                 real_max_value = (min_value == 0)
    143                     ? 0
    144                     :(((uintmax_t) -(min_value + 1)) + 1);
    145                
     95                real_max_value = -min_value;
    14696                /* fallthrough */
    14797        case '+':
    … …  
    154104                if (nptr[i] == '0') {
    155105                        if (tolower(nptr[i + 1]) == 'x') {
    156                                 /* 0x... is hex. */
    157106                                base = 16;
    158107                                i += 2;
    159108                        } else {
    160                                 /* 0... is octal. */
    161109                                base = 8;
    162110                        }
    163111                } else {
    164                         /* Anything else is decimal by default. */
    165112                        base = 10;
    166113                }
    167114                break;
    168115        case 16:
    169                 /* Allow hex number to be prefixed with "0x". */
    170116                if (nptr[i] == '0' && tolower(nptr[i + 1]) == 'x') {
    171117                        i += 2;
    … …  
    187133         * of overflow.
    188134         */
    189         uintmax_t max_safe_value = (real_max_value - base + 1) / base;
    190        
    191         uintmax_t result = 0;
     135        unsigned long long max_safe_value = (real_max_value - base + 1) / base;
     136       
     137        unsigned long long result = 0;
    192138       
    193139        if (real_max_value == 0) {
    … …  
    199145                        if (nptr[i] != '0') {
    200146                                errno = ERANGE;
    201                                 result = 0;
     147                                result = max_value;
    202148                        }
    203149                        i++;
    … …  
    206152       
    207153        while (is_digit_in_base(nptr[i], base)) {
    208                 int digit = digit_value(nptr[i]);
     154                int digit = get_digit_in_base(nptr[i], base);
    209155               
    210156                if (result > max_safe_value) {
    211157                        /* corner case, check for overflow */
    212158                       
    213                         uintmax_t boundary = (real_max_value - digit) / base;
     159                        unsigned long long
     160                            boundary = (real_max_value - digit) / base;
    214161                       
    215162                        if (result > boundary) {
    216163                                /* overflow */
    217164                                errno = ERANGE;
    218                                 result = real_max_value;
     165                                result = max_value;
    219166                                break;
    220167                        }
    … …  
    241188}
    242189
    243 /**
    244  * Convert a string to an integer.
    245  *
    246  * @param nptr Input string.
    247  * @return Result of the conversion.
    248  */
    249190int posix_atoi(const char *nptr)
    250191{
    251192        bool neg = false;
    252         uintmax_t result =
     193        unsigned long long result =
    253194            internal_strtol(nptr, NULL, 10, INT_MIN, INT_MAX, &neg);
    254195
    255         return (neg ? ((int) -result) : (int) result);
    256 }
    257 
    258 /**
    259  * Convert a string to a long integer.
    260  *
    261  * @param nptr Input string.
    262  * @return Result of the conversion.
    263  */
     196        return (int) (neg ? -result : result);
     197}
     198
    264199long posix_atol(const char *nptr)
    265200{
    266201        bool neg = false;
    267         uintmax_t result =
     202        unsigned long long result =
    268203            internal_strtol(nptr, NULL, 10, LONG_MIN, LONG_MAX, &neg);
    269204
    270         return (neg ? ((long) -result) : (long) result);
    271 }
    272 
    273 /**
    274  * Convert a string to a long long integer.
    275  *
    276  * @param nptr Input string.
    277  * @return Result of the conversion.
    278  */
     205        return (long) (neg ? -result : result);
     206}
     207
    279208long long posix_atoll(const char *nptr)
    280209{
    281210        bool neg = false;
    282         uintmax_t result =
     211        unsigned long long result =
    283212            internal_strtol(nptr, NULL, 10, LLONG_MIN, LLONG_MAX, &neg);
    284213
    285         return (neg ? ((long long) -result) : (long long) result);
    286 }
    287 
    288 /**
    289  * Convert a string to a long integer.
    290  *
    291  * @param nptr Input string.
    292  * @param endptr Pointer to the final part of the string which
    293  *     was not used for conversion.
    294  * @param base Expected base of the string representation.
    295  * @return Result of the conversion.
    296  */
     214        return (long long) (neg ? -result : result);
     215}
     216
    297217long posix_strtol(const char *restrict nptr, char **restrict endptr, int base)
    298218{
    299219        bool neg = false;
    300         uintmax_t result =
     220        unsigned long long result =
    301221            internal_strtol(nptr, endptr, base, LONG_MIN, LONG_MAX, &neg);
    302222
    303         return (neg ? ((long) -result) : ((long) result));
    304 }
    305 
    306 /**
    307  * Convert a string to a long long integer.
    308  *
    309  * @param nptr Input string.
    310  * @param endptr Pointer to the final part of the string which
    311  *     was not used for conversion.
    312  * @param base Expected base of the string representation.
    313  * @return Result of the conversion.
    314  */
     223        return (long) (neg ? -result : result);
     224}
     225
    315226long long posix_strtoll(
    316227    const char *restrict nptr, char **restrict endptr, int base)
    317228{
    318229        bool neg = false;
    319         uintmax_t result =
     230        unsigned long long result =
    320231            internal_strtol(nptr, endptr, base, LLONG_MIN, LLONG_MAX, &neg);
    321232
    322         return (neg ? ((long long) -result) : (long long) result);
    323 }
    324 
    325 /**
    326  * Convert a string to a largest signed integer type.
    327  *
    328  * @param nptr Input string.
    329  * @param endptr Pointer to the final part of the string which
    330  *     was not used for conversion.
    331  * @param base Expected base of the string representation.
    332  * @return Result of the conversion.
    333  */
    334 intmax_t posix_strtoimax(
    335     const char *restrict nptr, char **restrict endptr, int base)
    336 {
    337         bool neg = false;
    338         uintmax_t result =
    339             internal_strtol(nptr, endptr, base, INTMAX_MIN, INTMAX_MAX, &neg);
    340 
    341         return (neg ? ((intmax_t) -result) : (intmax_t) result);
    342 }
    343 
    344 /**
    345  * Convert a string to an unsigned long integer.
    346  *
    347  * @param nptr Input string.
    348  * @param endptr Pointer to the final part of the string which
    349  *     was not used for conversion.
    350  * @param base Expected base of the string representation.
    351  * @return Result of the conversion.
    352  */
     233        return (long long) (neg ? -result : result);
     234}
     235
    353236unsigned long posix_strtoul(
    354237    const char *restrict nptr, char **restrict endptr, int base)
    355238{
    356         uintmax_t result =
     239        unsigned long long result =
    357240            internal_strtol(nptr, endptr, base, 0, ULONG_MAX, NULL);
    358241
    … …  
    360243}
    361244
    362 /**
    363  * Convert a string to an unsigned long long integer.
    364  *
    365  * @param nptr Input string.
    366  * @param endptr Pointer to the final part of the string which
    367  *     was not used for conversion.
    368  * @param base Expected base of the string representation.
    369  * @return Result of the conversion.
    370  */
    371245unsigned long long posix_strtoull(
    372246    const char *restrict nptr, char **restrict endptr, int base)
    373247{
    374         uintmax_t result =
    375             internal_strtol(nptr, endptr, base, 0, ULLONG_MAX, NULL);
    376 
    377         return (unsigned long long) result;
    378 }
    379 
    380 /**
    381  * Convert a string to a largest unsigned integer type.
    382  *
    383  * @param nptr Input string.
    384  * @param endptr Pointer to the final part of the string which
    385  *     was not used for conversion.
    386  * @param base Expected base of the string representation.
    387  * @return Result of the conversion.
    388  */
    389 uintmax_t posix_strtoumax(
    390     const char *restrict nptr, char **restrict endptr, int base)
    391 {
    392         uintmax_t result =
    393             internal_strtol(nptr, endptr, base, 0, UINTMAX_MAX, NULL);
    394 
    395         return result;
    396 }
     248        return internal_strtol(nptr, endptr, base, 0, ULLONG_MAX, NULL);
     249}
     250
    397251
    398252/** @}
    399253 */
     254

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

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Backend for floating point conversions.
     32/** @file
    3333 */
    3434
    … …  
    5555#endif
    5656
    57 // TODO: clean up
     57// TODO: clean up, documentation
    5858
    5959// FIXME: ensure it builds and works on all platforms
    … …  
    116116};
    117117
    118 /**
    119  * Decides whether the argument is still in range representable by
    120  * long double or not.
    121  *
    122  * @param num Floating point number to be checked.
    123  * @return True if the argument is out of range, false otherwise.
    124  */
    125118static inline bool out_of_range(long double num)
    126119{
    … …  
    134127 * @param base Number to be multiplied.
    135128 * @param exponent Base 5 exponent.
    136  * @return base multiplied by 5**exponent.
     129 * @return base multiplied by 5**exponent
    137130 */
    138131static long double mul_pow5(long double base, int exponent)
    … …  
    180173 * @param base Number to be multiplied.
    181174 * @param exponent Base 2 exponent.
    182  * @return base multiplied by 2**exponent.
     175 * @return base multiplied by 2**exponent
    183176 */
    184177static long double mul_pow2(long double base, int exponent)
    … …  
    219212}
    220213
    221 /**
    222  * Convert decimal string representation of the floating point number.
    223  * Function expects the string pointer to be already pointed at the first
    224  * digit (i.e. leading optional sign was already consumed by the caller).
    225  *
    226  * @param sptr Pointer to the storage of the string pointer. Upon successful
    227  *     conversion, the string pointer is updated to point to the first
    228  *     unrecognized character.
    229  * @return An approximate representation of the input floating-point number.
    230  */
     214
    231215static long double parse_decimal(const char **sptr)
    232216{
    … …  
    331315}
    332316
    333 /**
    334  * Derive a hexadecimal digit from its character representation.
    335  *
    336  * @param ch Character representation of the hexadecimal digit.
    337  * @return Digit value represented by an integer.
    338  */
    339317static inline int hex_value(char ch)
    340318{
    … …  
    347325
    348326/**
    349  * Get the count of leading zero bits up to the maximum of 3 zero bits.
    350  *
    351327 * @param val Integer value.
    352328 * @return How many leading zero bits there are. (Maximum is 3)
    … …  
    363339}
    364340
    365 /**
    366  * Convert hexadecimal string representation of the floating point number.
    367  * Function expects the string pointer to be already pointed at the first
    368  * digit (i.e. leading optional sign and 0x prefix were already consumed
    369  * by the caller).
    370  *
    371  * @param sptr Pointer to the storage of the string pointer. Upon successful
    372  *     conversion, the string pointer is updated to point to the first
    373  *     unrecognized character.
    374  * @return Representation of the input floating-point number.
    375  */
    376341static long double parse_hexadecimal(const char **sptr)
    377342{
    … …  
    513478 * @param nptr Input string.
    514479 * @param endptr If non-NULL, *endptr is set to the position of the first
    515  *     unrecognized character.
     480 *    unrecognized character.
    516481 * @return An approximate representation of the input floating-point number.
    517482 */
    … …  
    547512               
    548513                if (endptr != NULL) {
    549                         *endptr = (char *) nptr;
    550                 }
    551                 errno = EINVAL;
    552                 return 0;
     514                        *endptr = (char *) &nptr[i + 3];
     515                }
     516                errno = ERANGE;
     517                return negative ? -0.0l : +0.0l;
    553518        }
    554519       
    … …  
    602567/** @}
    603568 */
     569

  • uspace/lib/posix/string.c

    reccd20e6 rdf0956ee  
    3131 * @{
    3232 */
    33 /** @file String manipulation.
     33/** @file
    3434 */
    3535
    … …  
    4848
    4949/**
    50  * Decides whether s2 is a prefix of s1.
    51  *
    52  * @param s1 String in which to look for a prefix.
    53  * @param s2 Prefix string to look for.
    54  * @return True if s2 is a prefix of s1, false otherwise.
     50 * Returns true if s2 is a prefix of s1.
     51 *
     52 * @param s1
     53 * @param s2
     54 * @return
    5555 */
    5656static bool begins_with(const char *s1, const char *s2)
    … …  
    6969 * if no occurence is found.
    7070 *
    71  * @param s1 String in which to look for the bytes.
    72  * @param s2 String of bytes to look for.
    73  * @return Pointer to the found byte on success, pointer to the
    74  *     string terminator otherwise.
     71 * @param s1
     72 * @param s2
     73 * @return
    7574 */
    7675static char *strpbrk_null(const char *s1, const char *s2)
    … …  
    8483
    8584/**
    86  * Copy a string.
    87  *
    88  * @param dest Destination pre-allocated buffer.
    89  * @param src Source string to be copied.
    90  * @return Pointer to the destination buffer.
    91  */
    92 char *posix_strcpy(char *restrict dest, const char *restrict src)
     85 *
     86 * @param dest
     87 * @param src
     88 * @return
     89 */
     90char *posix_strcpy(char *dest, const char *src)
    9391{
    9492        posix_stpcpy(dest, src);
    … …  
    9795
    9896/**
    99  * Copy fixed length string.
    100  *
    101  * @param dest Destination pre-allocated buffer.
    102  * @param src Source string to be copied.
    103  * @param n Number of bytes to be stored into destination buffer.
    104  * @return Pointer to the destination buffer.
    105  */
    106 char *posix_strncpy(char *restrict dest, const char *restrict src, size_t n)
     97 *
     98 * @param dest
     99 * @param src
     100 * @param n
     101 * @return
     102 */
     103char *posix_strncpy(char *dest, const char *src, size_t n)
    107104{
    108105        posix_stpncpy(dest, src, n);
    … …  
    111108
    112109/**
    113  * Copy a string.
    114  *
    115  * @param dest Destination pre-allocated buffer.
    116  * @param src Source string to be copied.
    117  * @return Pointer to the nul character in the destination string.
     110 *
     111 * @param dest
     112 * @param src
     113 * @return Pointer to the nul character in the dest string
    118114 */
    119115char *posix_stpcpy(char *restrict dest, const char *restrict src)
    … …  
    136132
    137133/**
    138  * Copy fixed length string.
    139  *
    140  * @param dest Destination pre-allocated buffer.
    141  * @param src Source string to be copied.
    142  * @param n Number of bytes to be stored into destination buffer.
    143  * @return Pointer to the first written nul character or &dest[n].
     134 *
     135 * @param dest
     136 * @param src
     137 * @param n
     138 * @return Pointer to the first written nul character or &dest[n]
    144139 */
    145140char *posix_stpncpy(char *restrict dest, const char *restrict src, size_t n)
    … …  
    167162
    168163/**
    169  * Concatenate two strings.
    170  *
    171  * @param dest String to which src shall be appended.
    172  * @param src String to be appended after dest.
    173  * @return Pointer to destination buffer.
    174  */
    175 char *posix_strcat(char *restrict dest, const char *restrict src)
     164 *
     165 * @param dest
     166 * @param src
     167 * @return
     168 */
     169char *posix_strcat(char *dest, const char *src)
    176170{
    177171        assert(dest != NULL);
    … …  
    183177
    184178/**
    185  * Concatenate a string with part of another.
    186  *
    187  * @param dest String to which part of src shall be appended.
    188  * @param src String whose part shall be appended after dest.
    189  * @param n Number of bytes to append after dest.
    190  * @return Pointer to destination buffer.
    191  */
    192 char *posix_strncat(char *restrict dest, const char *restrict src, size_t n)
     179 *
     180 * @param dest
     181 * @param src
     182 * @param n
     183 * @return
     184 */
     185char *posix_strncat(char *dest, const char *src, size_t n)
    193186{
    194187        assert(dest != NULL);
    … …  
    202195
    203196/**
    204  * Copy limited number of bytes in memory.
    205  *
    206  * @param dest Destination buffer.
    207  * @param src Source buffer.
    208  * @param c Character after which the copying shall stop.
    209  * @param n Number of bytes that shall be copied if not stopped earlier by c.
     197 *
     198 * @param dest
     199 * @param src
     200 * @param c
     201 * @param n
    210202 * @return Pointer to the first byte after c in dest if found, NULL otherwise.
    211203 */
    212 void *posix_memccpy(void *restrict dest, const void *restrict src, int c, size_t n)
     204void *posix_memccpy(void *dest, const void *src, int c, size_t n)
    213205{
    214206        assert(dest != NULL);
    … …  
    231223
    232224/**
    233  * Duplicate a string.
    234  *
    235  * @param s String to be duplicated.
    236  * @return Newly allocated copy of the string.
     225 *
     226 * @param s
     227 * @return Newly allocated string
    237228 */
    238229char *posix_strdup(const char *s)
    … …  
    242233
    243234/**
    244  * Duplicate a specific number of bytes from a string.
    245  *
    246  * @param s String to be duplicated.
    247  * @param n Maximum length of the resulting string..
    248  * @return Newly allocated string copy of length at most n.
     235 *
     236 * @param s
     237 * @param n
     238 * @return Newly allocated string of length at most n
    249239 */
    250240char *posix_strndup(const char *s, size_t n)
    … …  
    265255
    266256/**
    267  * Compare bytes in memory.
    268  *
    269  * @param mem1 First area of memory to be compared.
    270  * @param mem2 Second area of memory to be compared.
    271  * @param n Maximum number of bytes to be compared.
     257 *
     258 * @param mem1
     259 * @param mem2
     260 * @param n
    272261 * @return Difference of the first pair of inequal bytes,
    273  *     or 0 if areas have the same content.
     262 *     or 0 if areas have the same content
    274263 */
    275264int posix_memcmp(const void *mem1, const void *mem2, size_t n)
    … …  
    283272        for (size_t i = 0; i < n; ++i) {
    284273                if (s1[i] != s2[i]) {
    285                         return s1[i] - s2[i];
     274                        return s2[i] - s1[i];
    286275                }
    287276        }
    … …  
    291280
    292281/**
    293  * Compare two strings.
    294  *
    295  * @param s1 First string to be compared.
    296  * @param s2 Second string to be compared.
    297  * @return Difference of the first pair of inequal characters,
    298  *     or 0 if strings have the same content.
     282 *
     283 * @param s1
     284 * @param s2
     285 * @return
    299286 */
    300287int posix_strcmp(const char *s1, const char *s2)
    … …  
    307294
    308295/**
    309  * Compare part of two strings.
    310  *
    311  * @param s1 First string to be compared.
    312  * @param s2 Second string to be compared.
    313  * @param n Maximum number of characters to be compared.
    314  * @return Difference of the first pair of inequal characters,
    315  *     or 0 if strings have the same content.
     296 *
     297 * @param s1
     298 * @param s2
     299 * @param n
     300 * @return
    316301 */
    317302int posix_strncmp(const char *s1, const char *s2, size_t n)
    … …  
    322307        for (size_t i = 0; i < n; ++i) {
    323308                if (s1[i] != s2[i]) {
    324                         return s1[i] - s2[i];
     309                        return s2[i] - s1[i];
    325310                }
    326311                if (s1[i] == '\0') {
    … …  
    333318
    334319/**
    335  * Find byte in memory.
    336  *
    337  * @param mem Memory area in which to look for the byte.
    338  * @param c Byte to look for.
    339  * @param n Maximum number of bytes to be inspected.
    340  * @return Pointer to the specified byte on success,
    341  *     NULL pointer otherwise.
     320 *
     321 * @param mem
     322 * @param c
     323 * @param n
     324 * @return
    342325 */
    343326void *posix_memchr(const void *mem, int c, size_t n)
    … …  
    356339
    357340/**
    358  * Scan string for a first occurence of a character.
    359  *
    360  * @param s String in which to look for the character.
    361  * @param c Character to look for.
    362  * @return Pointer to the specified character on success,
    363  *     NULL pointer otherwise.
     341 *
     342 * @param s
     343 * @param c
     344 * @return
    364345 */
    365346char *posix_strchr(const char *s, int c)
    … …  
    372353
    373354/**
    374  * Scan string for a last occurence of a character.
    375  *
    376  * @param s String in which to look for the character.
    377  * @param c Character to look for.
    378  * @return Pointer to the specified character on success,
    379  *     NULL pointer otherwise.
     355 *
     356 * @param s
     357 * @param c
     358 * @return
    380359 */
    381360char *posix_strrchr(const char *s, int c)
    … …  
    397376}
    398377
    399 /**
    400  * Scan string for a first occurence of a character.
    401  *
    402  * @param s String in which to look for the character.
    403  * @param c Character to look for.
    404  * @return Pointer to the specified character on success, pointer to the
    405  *     string terminator otherwise.
    406  */
    407378char *gnu_strchrnul(const char *s, int c)
    408379{
    … …  
    417388
    418389/**
    419  * Scan a string for a first occurence of one of provided bytes.
    420  *
    421  * @param s1 String in which to look for the bytes.
    422  * @param s2 String of bytes to look for.
    423  * @return Pointer to the found byte on success,
    424  *     NULL pointer otherwise.
     390 *
     391 * @param s1
     392 * @param s2
     393 * @return
    425394 */
    426395char *posix_strpbrk(const char *s1, const char *s2)
    … …  
    434403
    435404/**
    436  * Get the length of a complementary substring.
    437  *
    438  * @param s1 String that shall be searched for complementary prefix.
    439  * @param s2 String of bytes that shall not occur in the prefix.
    440  * @return Length of the prefix.
     405 *
     406 * @param s1
     407 * @param s2
     408 * @return
    441409 */
    442410size_t posix_strcspn(const char *s1, const char *s2)
    … …  
    450418
    451419/**
    452  * Get length of a substring.
    453  *
    454  * @param s1 String that shall be searched for prefix.
    455  * @param s2 String of bytes that the prefix must consist of.
    456  * @return Length of the prefix.
     420 *
     421 * @param s1
     422 * @param s2
     423 * @return
    457424 */
    458425size_t posix_strspn(const char *s1, const char *s2)
    … …  
    471438
    472439/**
    473  * Find a substring.
    474  *
    475  * @param s1 String in which to look for a substring.
    476  * @param s2 Substring to look for.
    477  * @return Pointer to the first character of the substring in s1, or NULL if
    478  *     not found.
     440 *
     441 * @param s1
     442 * @param s2
     443 * @return
    479444 */
    480445char *posix_strstr(const char *s1, const char *s2)
    … …  
    502467
    503468/**
    504  * String comparison using collating information.
    505  *
    506469 * Currently ignores locale and just calls strcmp.
    507470 *
    508  * @param s1 First string to be compared.
    509  * @param s2 Second string to be compared.
    510  * @return Difference of the first pair of inequal characters,
    511  *     or 0 if strings have the same content.
     471 * @param s1
     472 * @param s2
     473 * @return
    512474 */
    513475int posix_strcoll(const char *s1, const char *s2)
    … …  
    520482
    521483/**
    522  * Transform a string in such a way that the resulting string yields the same
    523  * results when passed to the strcmp as if the original string is passed to
    524  * the strcoll.
    525  *
    526  * Since strcoll is equal to strcmp here, this just makes a copy.
    527  *
    528  * @param s1 Transformed string.
    529  * @param s2 Original string.
    530  * @param n Maximum length of the transformed string.
    531  * @return Length of the transformed string.
    532  */
    533 size_t posix_strxfrm(char *restrict s1, const char *restrict s2, size_t n)
     484 * strcoll is equal to strcmp here, so this just makes a copy.
     485 *
     486 * @param s1
     487 * @param s2
     488 * @param n
     489 * @return
     490 */
     491size_t posix_strxfrm(char *s1, const char *s2, size_t n)
    534492{
    535493        assert(s1 != NULL || n == 0);
    … …  
    546504
    547505/**
    548  * Get error message string.
    549  *
    550  * @param errnum Error code for which to obtain human readable string.
    551  * @return Error message.
     506 *
     507 * @param errnum
     508 * @return
    552509 */
    553510char *posix_strerror(int errnum)
    … …  
    561518
    562519/**
    563  * Get error message string.
    564  *
    565  * @param errnum Error code for which to obtain human readable string.
    566  * @param buf Buffer to store a human readable string to.
    567  * @param bufsz Size of buffer pointed to by buf.
    568  * @return Zero on success, errno otherwise.
     520 *
     521 * @param errnum Error code
     522 * @param buf Buffer to store a human readable string to
     523 * @param bufsz Size of buffer pointed to by buf
     524 * @return
    569525 */
    570526int posix_strerror_r(int errnum, char *buf, size_t bufsz)
    … …  
    585541
    586542/**
    587  * Get length of the string.
    588  *
    589  * @param s String which length shall be determined.
    590  * @return Length of the string.
     543 *
     544 * @param s
     545 * @return
    591546 */
    592547size_t posix_strlen(const char *s)
    … …  
    598553
    599554/**
    600  * Get limited length of the string.
    601  *
    602  * @param s String which length shall be determined.
    603  * @param n Maximum number of bytes that can be examined to determine length.
    604  * @return The lower of either string length or n limit.
     555 *
     556 * @param s
     557 * @param n
     558 * @return
    605559 */
    606560size_t posix_strnlen(const char *s, size_t n)
    … …  
    619573
    620574/**
    621  * Get description of a signal.
    622  *
    623  * @param signum Signal number.
    624  * @return Human readable signal description.
     575 *
     576 * @param signum
     577 * @return
    625578 */
    626579char *posix_strsignal(int signum)

  • uspace/lib/posix/string.h

    reccd20e6 rdf0956ee  
    3131 * @{
    3232 */
    33 /** @file String manipulation.
     33/** @file
    3434 */
    3535
    … …  
    103103extern size_t posix_strnlen(const char *s, size_t n);
    104104
    105 /* Signal Messages */
     105/* Signal messages */
    106106extern char *posix_strsignal(int signum);
    107107
    108 /* Legacy Declarations */
     108/* Legacy declarations */
    109109#ifndef POSIX_STRINGS_H_
    110110extern int posix_ffs(int i);

  • uspace/lib/posix/strings.c

    reccd20e6 rdf0956ee  
    3131 * @{
    3232 */
    33 /** @file Additional string manipulation.
     33/** @file
    3434 */
    3535
    … …  
    4545
    4646/**
    47  * Find first set bit (beginning with the least significant bit).
    4847 *
    49  * @param i Integer in which to look for the first set bit.
    50  * @return Index of first set bit. Bits are numbered starting at one.
     48 * @param i
     49 * @return
    5150 */
    5251int posix_ffs(int i)
    … …  
    8382
    8483/**
    85  * Compare two strings (case-insensitive).
    8684 *
    87  * @param s1 First string to be compared.
    88  * @param s2 Second string to be compared.
    89  * @return Difference of the first pair of inequal characters,
    90  *     or 0 if strings have the same content.
     85 * @param s1
     86 * @param s2
     87 * @return
    9188 */
    9289int posix_strcasecmp(const char *s1, const char *s2)
    … …  
    9693
    9794/**
    98  * Compare part of two strings (case-insensitive).
    9995 *
    100  * @param s1 First string to be compared.
    101  * @param s2 Second string to be compared.
    102  * @param n Maximum number of characters to be compared.
    103  * @return Difference of the first pair of inequal characters,
    104  *     or 0 if strings have the same content.
     96 * @param s1
     97 * @param s2
     98 * @param n
     99 * @return
    105100 */
    106101int posix_strncasecmp(const char *s1, const char *s2, size_t n)
    … …  
    121116
    122117/**
    123  * Compare two memory areas.
    124118 *
    125  * @param mem1 Pointer to the first area to compare.
    126  * @param mem2 Pointer to the second area to compare.
    127  * @param n Common size of both areas.
    128  * @return If n is 0, return zero. If the areas match, return
    129  *     zero. Otherwise return non-zero.
     119 * @param mem1
     120 * @param mem2
     121 * @param n
     122 * @return
    130123 */
    131124int posix_bcmp(const void *mem1, const void *mem2, size_t n)
    … …  
    135128
    136129/**
    137  * Copy bytes in memory with overlapping areas.
    138130 *
    139  * @param src Source area.
    140  * @param dest Destination area.
    141  * @param n Number of bytes to copy.
     131 * @param dest
     132 * @param src
     133 * @param n
    142134 */
    143 void posix_bcopy(const void *src, void *dest, size_t n)
     135void posix_bcopy(const void *dest, void *src, size_t n)
    144136{
    145137        /* Note that memmove has different order of arguments. */
    146         memmove(dest, src, n);
     138        memmove(src, dest, n);
    147139}
    148140
    149141/**
    150  * Reset bytes in memory area to zero.
    151142 *
    152  * @param mem Memory area to be zeroed.
    153  * @param n Number of bytes to reset.
     143 * @param mem
     144 * @param n
    154145 */
    155146void posix_bzero(void *mem, size_t n)
    … …  
    159150
    160151/**
    161  * Scan string for a first occurence of a character.
    162152 *
    163  * @param s String in which to look for the character.
    164  * @param c Character to look for.
    165  * @return Pointer to the specified character on success,
    166  *     NULL pointer otherwise.
     153 * @param s
     154 * @param c
     155 * @return
    167156 */
    168157char *posix_index(const char *s, int c)
    … …  
    172161
    173162/**
    174  * Scan string for a last occurence of a character.
    175  *
    176  * @param s String in which to look for the character.
    177  * @param c Character to look for.
    178  * @return Pointer to the specified character on success,
    179  *     NULL pointer otherwise.
     163 *
     164 * @param s
     165 * @param c
     166 * @return
    180167 */
    181168char *posix_rindex(const char *s, int c)

  • uspace/lib/posix/strings.h

    reccd20e6 rdf0956ee  
    3131 * @{
    3232 */
    33 /** @file Additional string manipulation.
     33/** @file
    3434 */
    3535
    … …  
    3737#define POSIX_STRINGS_H_
    3838
     39#ifndef POSIX_STRING_H_
    3940/* Search Functions */
    40 #ifndef POSIX_STRING_H_
    4141extern int posix_ffs(int i);
    4242#endif
    … …  
    5656/* Legacy Functions */
    5757extern int posix_bcmp(const void *mem1, const void *mem2, size_t n);
    58 extern void posix_bcopy(const void *src, void *dest, size_t n);
     58extern void posix_bcopy(const void *dest, void *src, size_t n);
    5959extern void posix_bzero(void *mem, size_t n);
    6060extern char *posix_index(const char *s, int c);

  • uspace/lib/posix/sys/mman.h

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Memory management declarations.
     32/** @file
    3333 */
    3434

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

    reccd20e6 rdf0956ee  
    3131 * @{
    3232 */
    33 /** @file File status handling.
     33/** @file
    3434 */
    3535
    … …  
    8080        int rc = fstat(fd, &hst);
    8181        if (rc < 0) {
    82                 /* fstat() returns negative error code instead of using errno. */
     82                /* fstat() returns negative error code instead of using errno.
     83                 */
    8384                errno = -rc;
    8485                return -1;
    … …  
    9596 * @return Zero on success, -1 otherwise.
    9697 */
    97 int posix_lstat(const char *restrict path, struct posix_stat *restrict st)
     98int posix_lstat(const char *path, struct posix_stat *st)
    9899{
    99100        /* There are currently no symbolic links in HelenOS. */
    … …  
    108109 * @return Zero on success, -1 otherwise.
    109110 */
    110 int posix_stat(const char *restrict path, struct posix_stat *restrict st)
     111int posix_stat(const char *path, struct posix_stat *st)
    111112{
    112113        struct stat hst;
    113114        int rc = stat(path, &hst);
    114115        if (rc < 0) {
    115                 /* stat() returns negative error code instead of using errno. */
     116                /* stat() returns negative error code instead of using errno.
     117                 */
    116118                errno = -rc;
    117119                return -1;

  • uspace/lib/posix/sys/stat.h

    reccd20e6 rdf0956ee  
    3131 * @{
    3232 */
    33 /** @file File status handling.
     33/** @file
    3434 */
    3535

  • uspace/lib/posix/sys/types.h

    reccd20e6 rdf0956ee  
    3131 * @{
    3232 */
    33 /** @file Data types definitions.
     33/** @file
    3434 */
    3535
    … …  
    4949typedef sysarg_t posix_dev_t;
    5050
    51 /* PThread Types */
     51/* PThread types */
    5252typedef struct posix_thread_attr posix_thread_attr_t;
    5353
    54 /* Clock Types */
     54/* Clock types */
    5555typedef long posix_clock_t;
    5656typedef int posix_clockid_t;

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

    reccd20e6 rdf0956ee  
    3131 * @{
    3232 */
    33 /** @file Support for waiting.
     33/** @file
    3434 */
    3535
    … …  
    6565/** @}
    6666 */
     67

  • uspace/lib/posix/sys/wait.h

    reccd20e6 rdf0956ee  
    3030 * @{
    3131 */
    32 /** @file Support for waiting.
     32/** @file
    3333 */
    3434

  • uspace/lib/posix/time.c

    reccd20e6 rdf0956ee  
    3131 * @{
    3232 */
    33 /** @file Time measurement support.
     33/** @file
    3434 */
    3535
    … …  
    6363#define SECS_PER_DAY (SECS_PER_HOUR * HOURS_PER_DAY)
    6464
    65 /**
    66  *
    67  * @param year
    68  * @return
    69  */
    7065static bool _is_leap_year(time_t year)
    7166{
    … …  
    8176}
    8277
    83 /**
    84  *
    85  * @param year
    86  * @param mon
    87  * @return
    88  */
    8978static int _days_in_month(time_t year, time_t mon)
    9079{
    … …  
    10392}
    10493
    105 /**
    106  *
    107  * @param year
    108  * @param mon
    109  * @param mday
    110  * @return
    111  */
    11294static int _day_of_year(time_t year, time_t mon, time_t mday)
    11395{
    … …  
    120102}
    121103
    122 /**
    123  * Integer division that rounds to negative infinity.
    124  *
    125  * @param op1
    126  * @param op2
    127  * @return
     104/* Integer division that rounds to negative infinity.
    128105 */
    129106static time_t _floor_div(time_t op1, time_t op2)
    … …  
    136113}
    137114
    138 /**
    139  * Modulo that rounds to negative infinity.
    140  *
    141  * @param op1
    142  * @param op2
    143  * @return
     115/* Modulo that rounds to negative infinity.
    144116 */
    145117static time_t _floor_mod(time_t op1, time_t op2)
    … …  
    160132}
    161133
    162 /**
    163  *
    164  * @param year
    165  * @param mon
    166  * @param mday
    167  * @return
    168  */
    169134static time_t _days_since_epoch(time_t year, time_t mon, time_t mday)
    170135{
    … …  
    174139}
    175140
    176 /**
    177  * Assumes normalized broken-down time.
    178  *
    179  * @param tm
    180  * @return
    181  */
     141/* Assumes normalized broken-down time. */
    182142static time_t _secs_since_epoch(const struct posix_tm *tm)
    183143{
    … …  
    187147}
    188148
    189 /**
    190  *
    191  * @param year
    192  * @param mon
    193  * @param mday
    194  * @return
    195  */
    196149static int _day_of_week(time_t year, time_t mon, time_t mday)
    197150{
    … …  
    212165};
    213166
    214 /**
    215  *
    216  * @param ltm
    217  * @param ptm
    218  */
    219167static void _posix_to_long_tm(struct _long_tm *ltm, struct posix_tm *ptm)
    220168{
    … …  
    231179}
    232180
    233 /**
    234  *
    235  * @param ptm
    236  * @param ltm
    237  */
    238181static void _long_to_posix_tm(struct posix_tm *ptm, struct _long_tm *ltm)
    239182{
    … …  
    253196}
    254197
    255 /**
    256  *
    257  * @param tm
    258  */
    259198static void _normalize_time(struct _long_tm *tm)
    260199{
    … …  
    302241}
    303242
    304 /**
    305  * Which day the week-based year starts on relative to the first calendar day.
     243/* Which day the week-based year starts on relative to the first calendar day.
    306244 * E.g. if the year starts on December 31st, the return value is -1.
    307  *
    308  * @param year
    309  * @return
    310245 */
    311246static int _wbyear_offset(int year)
    … …  
    315250}
    316251
    317 /**
    318  * Returns week-based year of the specified time.
     252/* Returns week-based year of the specified time.
    319253 * Assumes normalized broken-down time.
    320  *
    321  * @param tm
    322  * @return
    323254 */
    324255static int _wbyear(const struct posix_tm *tm)
    … …  
    337268}
    338269
    339 /**
    340  * Week number of the year, assuming weeks start on sunday.
    341  * The first Sunday of January is the first day of week 1;
    342  * days in the new year before this are in week 0.
     270/** Week number of the year, assuming weeks start on sunday.
     271 *  The first Sunday of January is the first day of week 1;
     272 *  days in the new year before this are in week 0.
    343273 *
    344274 * @param tm Normalized broken-down time.
    … …  
    351281}
    352282
    353 /**
    354  * Week number of the year, assuming weeks start on monday.
    355  * If the week containing January 1st has four or more days in the new year,
    356  * then it is considered week 1. Otherwise, it is the last week of the previous
    357  * year, and the next week is week 1. Both January 4th and the first Thursday
    358  * of January are always in week 1.
     283/** Week number of the year, assuming weeks start on monday.
     284 *  If the week containing January 1st has four or more days in the new year,
     285 *  then it is considered week 1. Otherwise, it is the last week of the previous
     286 *  year, and the next week is week 1. Both January 4th and the first Thursday
     287 *  of January are always in week 1.
    359288 *
    360289 * @param tm Normalized broken-down time.
    … …  
    376305}
    377306
    378 /**
    379  * Week number of the year, assuming weeks start on monday.
    380  * The first Monday of January is the first day of week 1;
    381  * days in the new year before this are in week 0.
     307/** Week number of the year, assuming weeks start on monday.
     308 *  The first Monday of January is the first day of week 1;
     309 *  days in the new year before this are in week 0.
    382310 *
    383311 * @param tm Normalized broken-down time.
    … …  
    396324char *posix_tzname[2];
    397325
    398 /**
    399  *
    400  */
    401326void posix_tzset(void)
    402327{
    … …  
    408333}
    409334
    410 /**
    411  *
    412  * @param time1
    413  * @param time0
    414  * @return
    415  */
    416335double posix_difftime(time_t time1, time_t time0)
    417336{
    … …  
    419338}
    420339
    421 /**
    422  * This function first normalizes the provided broken-down time
    423  * (moves all values to their proper bounds) and then tries to
    424  * calculate the appropriate time_t representation.
    425  *
    426  * @param tm Broken-down time.
     340/** This function first normalizes the provided broken-down time
     341 *  (moves all values to their proper bounds) and then tries to
     342 *  calculate the appropriate time_t representation.
     343 *
     344 * @param timeptr Broken-down time.
    427345 * @return time_t representation of the time, undefined value on overflow
    428346 */
    … …  
    440358}
    441359
    442 /**
    443  *
    444  * @param timer
    445  * @return
    446  */
    447360struct posix_tm *posix_gmtime(const time_t *timer)
    448361{
    … …  
    451364}
    452365
    453 /**
    454  *
    455  * @param timer
    456  * @param result
    457  * @return
    458  */
    459366struct posix_tm *posix_gmtime_r(const time_t *restrict timer,
    460367    struct posix_tm *restrict result)
    … …  
    487394/**
    488395 *
    489  * @param timer
     396 * @param timep
    490397 * @return
    491398 */
    … …  
    496403}
    497404
    498 /**
    499  *
    500  * @param timer
    501  * @param result
    502  * @return
    503  */
    504405struct posix_tm *posix_localtime_r(const time_t *restrict timer,
    505406    struct posix_tm *restrict result)
    … …  
    512413/**
    513414 *
    514  * @param timeptr
     415 * @param tm
    515416 * @return
    516417 */
    … …  
    521422}
    522423
    523 /**
    524  *
    525  * @param timeptr
    526  * @param buf
    527  * @return
    528  */
    529424char *posix_asctime_r(const struct posix_tm *restrict timeptr,
    530425    char *restrict buf)
    … …  
    553448/**
    554449 *
    555  * @param timer
     450 * @param timep
    556451 * @return
    557452 */
    … …  
    565460}
    566461
    567 /**
    568  *
    569  * @param timer
    570  * @param buf
    571  * @return
    572  */
    573462char *posix_ctime_r(const time_t *timer, char *buf)
    574463{
    … …  
    588477 * @return
    589478 */
    590 size_t posix_strftime(char *restrict s, size_t maxsize,
    591     const char *restrict format, const struct posix_tm *restrict tm)
     479size_t posix_strftime(char *s, size_t maxsize,
     480    const char *format, const struct posix_tm *tm)
    592481{
    593482        // TODO: use locale
    … …  
    766655}
    767656
    768 /**
    769  *
    770  * @param s
    771  * @param maxsize
    772  * @param format
    773  * @param tm
    774  * @param loc
    775  * @return
    776  */
    777 extern size_t posix_strftime_l(char *restrict s, size_t maxsize,
    778     const char *restrict format, const struct posix_tm *restrict tm,
    779     posix_locale_t loc)
    780 {
    781         // TODO
    782         not_implemented();
    783 }
    784 
    785 /**
    786  *
    787  * @param clock_id
    788  * @param res
    789  * @return
    790  */
    791657int posix_clock_getres(posix_clockid_t clock_id, struct posix_timespec *res)
    792658{
    … …  
    804670}
    805671
    806 /**
    807  *
    808  * @param clock_id
    809  * @param tp
    810  * @return
    811  */
    812672int posix_clock_gettime(posix_clockid_t clock_id, struct posix_timespec *tp)
    813673{
    … …  
    828688}
    829689
    830 /**
    831  *
    832  * @param clock_id
    833  * @param tp
    834  * @return
    835  */
    836690int posix_clock_settime(posix_clockid_t clock_id,
    837691    const struct posix_timespec *tp)
    … …  
    852706}
    853707
    854 /**
    855  *
    856  * @param clock_id
    857  * @param flags
    858  * @param rqtp
    859  * @param rmtp
    860  * @return
    861  */
    862708int posix_clock_nanosleep(posix_clockid_t clock_id, int flags,
    863709    const struct posix_timespec *rqtp, struct posix_timespec *rmtp)
    … …  
    889735};
    890736
    891 /**
    892  *
    893  * @param clockid
    894  * @param evp
    895  * @param timerid
    896  * @return
    897  */
    898737int posix_timer_create(posix_clockid_t clockid,
    899738    struct posix_sigevent *restrict evp,
    … …  
    904743}
    905744
    906 /**
    907  *
    908  * @param timerid
    909  * @return
    910  */
    911745int posix_timer_delete(posix_timer_t timerid)
    912746{
    … …  
    915749}
    916750
    917 /**
    918  *
    919  * @param timerid
    920  * @return
    921  */
    922751int posix_timer_getoverrun(posix_timer_t timerid)
    923752{
    … …  
    926755}
    927756
    928 /**
    929  *
    930  * @param timerid
    931  * @param value
    932  * @return
    933  */
    934757int posix_timer_gettime(posix_timer_t timerid,
    935758    struct posix_itimerspec *value)
    … …  
    939762}
    940763
    941 /**
    942  *
    943  * @param timerid
    944  * @param flags
    945  * @param value
    946  * @param ovalue
    947  * @return
    948  */
    949764int posix_timer_settime(posix_timer_t timerid, int flags,
    950765    const struct posix_itimerspec *restrict value,
    … …  
    968783        if (task_stats) {
    969784                total_cycles = (posix_clock_t) (task_stats->kcycles + task_stats->ucycles);
    970                 free(task_stats);
    971                 task_stats = 0;
    972         }
     785        }
     786        free(task_stats);
     787        task_stats = 0;
    973788
    974789        return total_cycles;

  • uspace/lib/posix/time.h

    reccd20e6 rdf0956ee  
    3131 * @{
    3232 */
    33 /** @file Time measurement support.
     33/** @file
    3434 */
    3535
    … …  
    9494
    9595/* Timezones */
     96
    9697extern int posix_daylight;
    9798extern long posix_timezone;
    9899extern char *posix_tzname[2];
     100
    99101extern void posix_tzset(void);
    100102
    101 /* Elapsed Time */
     103/* time_t */
     104
    102105extern double posix_difftime(time_t time1, time_t time0);
    103106
    104107/* Broken-down Time */
    105 extern time_t posix_mktime(struct posix_tm *tm);
     108extern time_t posix_mktime(struct posix_tm *timeptr);
    106109extern struct posix_tm *posix_gmtime(const time_t *timer);
    107110extern struct posix_tm *posix_gmtime_r(const time_t *restrict timer,
    … …  
    117120extern char *posix_ctime(const time_t *timer);
    118121extern char *posix_ctime_r(const time_t *timer, char *buf);
     122
    119123extern size_t posix_strftime(char *restrict s, size_t maxsize,
    120124    const char *restrict format, const struct posix_tm *restrict tm);
     125
    121126extern size_t posix_strftime_l(char *restrict s, size_t maxsize,
    122127    const char *restrict format, const struct posix_tm *restrict tm,
    123128    posix_locale_t loc);
    124129
    125 /* Clocks */
     130/* Clocks. */
     131
    126132extern int posix_clock_getres(posix_clockid_t clock_id,
    127133    struct posix_timespec *res);
    … …  
    133139    const struct posix_timespec *rqtp, struct posix_timespec *rmtp);
    134140
     141/* Timers. */
     142
    135143#if 0
    136144
    137 /* Timers */
    138145extern int posix_timer_create(posix_clockid_t clockid,
    139146    struct posix_sigevent *restrict evp,
    … …  
    152159extern posix_clock_t posix_clock(void);
    153160
     161
    154162#ifndef LIBPOSIX_INTERNAL
    155163        #define tm posix_tm
     164
    156165        #define timespec posix_timespec
    157166        #define itimerspec posix_itimerspec
    158167        #define timer_t posix_timer_t
    159168
    160         #define daylight posix_daylight
    161         #define timezone posix_timezone
    162         #define tzname posix_tzname
    163         #define tzset posix_tzset
    164 
    165169        #define difftime posix_difftime
    166 
    167170        #define mktime posix_mktime
    168171        #define gmtime posix_gmtime
    … …  
    171174        #define localtime_r posix_localtime_r
    172175
     176        #define daylight posix_daylight
     177        #define timezone posix_timezone
     178        #define tzname posix_tzname
     179        #define tzset posix_tzset
     180
    173181        #define asctime posix_asctime
    174182        #define asctime_r posix_asctime_r
    … …  
    176184        #define ctime_r posix_ctime_r
    177185        #define strftime posix_strftime
    178         #define strftime_l posix_strftime_l
    179186
    180187        #define clock_getres posix_clock_getres

  • uspace/lib/posix/unistd.c

    reccd20e6 rdf0956ee  
    3131 * @{
    3232 */
    33 /** @file Miscellaneous standard definitions.
     33/** @file
    3434 */
    3535
    … …  
    9090        /* Always returns false, because there is no easy way to find
    9191     * out under HelenOS. */
    92         return 0;
     92        return false;
    9393}
    9494
    … …  
    207207                /* Check file existence by attempt to open it. */
    208208                int fd = open(path, O_RDONLY);
    209                 if (fd != -1) {
     209                if (fd < 0) {
     210                        /* FIXME: open() returns error code as negative retval. */
     211                        errno = -fd;
     212                        fd = -1;
     213                } else {
    210214                        close(fd);
    211215                }
    … …  
    235239                clk_tck = ((long) cpu_stats[0].frequency_mhz) * 1000000L;
    236240        }
    237         if (cpu_stats) {
    238                 free(cpu_stats);
    239                 cpu_stats = 0;
    240         }
     241        free(cpu_stats);
     242        cpu_stats = 0;
    241243
    242244        long phys_pages = 0;
    … …  
    246248                phys_pages = (long) (mem_stats->total / getpagesize());
    247249                avphys_pages = (long) (mem_stats->free / getpagesize());
    248                 free(mem_stats);
    249                 mem_stats = 0;
    250         }
     250        }
     251        free(mem_stats);
     252        mem_stats = 0;
    251253
    252254        switch (name) {

  • uspace/lib/posix/unistd.h

    reccd20e6 rdf0956ee  
    3131 * @{
    3232 */
    33 /** @file Miscellaneous standard definitions.
     33/** @file
    3434 */
    3535
Note: See TracChangeset for help on using the changeset viewer.