Changeset 10fdd0e in mainline


Ignore:
Timestamp:
2011-06-26T01:34:47Z (13 years ago)
Author:
Petr Koupy <petr.koupy@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f5b2522
Parents:
343d0da1 (diff), 4d41821 (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.
Message:

Merge libposix changes.

Location:
uspace/lib/posix
Files:
5 added
6 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/posix/Makefile

    r343d0da1 r10fdd0e  
    4141        ctype.c \
    4242        fcntl.c \
     43        fnmatch.c \
    4344        math.c \
     45        pwd.c \
    4446        stdio.c \
    4547        stdlib.c \
     48        stdlib/strtol.c \
    4649        stdlib/strtold.c \
    4750        string.c \

  • uspace/lib/posix/signal.h

    r343d0da1 r10fdd0e  
    3737
    3838#include "libc/errno.h"
     39#include "sys/types.h"
    3940
    4041/* HelenOS doesn't have signals, so calls to functions of this header
    … …  
    5152#undef SIG_ERR
    5253#define SIG_ERR ((void (*)(int)) 0)
     54#undef SIG_HOLD
     55#define SIG_HOLD ((void (*)(int)) 0)
    5356#undef SIG_IGN
    5457#define SIG_IGN ((void (*)(int)) 0)
    … …  
    5962
    6063typedef int posix_sig_atomic_t;
     64typedef int posix_sigset_t;
     65typedef struct posix_mcontext {
     66        // FIXME: should not be empty to avoid compiler warnings (-pedantic)
     67        int dummy;
     68} posix_mcontext_t;
     69
     70union posix_sigval {
     71        int sival_int;
     72        void *sival_ptr;
     73};
     74
     75struct posix_sigevent {
     76        int sigev_notify; /* Notification type. */
     77        int sigev_signo; /* Signal number. */
     78        union posix_sigval sigev_value; /* Signal value. */
     79        void (*sigev_notify_function)(union posix_sigval); /* Notification function. */
     80        posix_thread_attr_t *sigev_notify_attributes; /* Notification attributes. */
     81};
     82
     83typedef struct {
     84        int si_signo;
     85        int si_code;
     86
     87        int si_errno;
     88
     89        pid_t si_pid;
     90        uid_t si_uid;
     91        void *si_addr;
     92        int si_status;
     93
     94        long si_band;
     95
     96        union posix_sigval si_value;
     97} posix_siginfo_t;
     98
     99struct posix_sigaction {
     100        void (*sa_handler)(int);
     101        posix_sigset_t sa_mask;
     102        int sa_flags;
     103        void (*sa_sigaction)(int, posix_siginfo_t *, void *);
     104};
     105
     106typedef struct {
     107        void *ss_sp;
     108        size_t ss_size;
     109        int ss_flags;
     110} posix_stack_t;
     111
     112typedef struct posix_ucontext {
     113        struct posix_ucontext *uc_link;
     114        posix_sigset_t uc_sigmask;
     115        posix_stack_t uc_stack;
     116        posix_mcontext_t uc_mcontext;
     117} posix_ucontext_t;
     118
     119
     120/* Values of posix_sigevent::sigev_notify */
     121#undef SIGEV_NONE
     122#define SIGEV_NONE 0
     123#undef SIGEV_SIGNAL
     124#define SIGEV_SIGNAL 0
     125#undef SIGEV_THREAD
     126#define SIGEV_THREAD 0
     127
     128#undef SIGRT_MIN
     129#define SIGRT_MIN 0
     130#undef SIGRT_MAX
     131#define SIGRT_MAX 0
     132
     133#undef SIG_BLOCK
     134#define SIG_BLOCK 0
     135#undef SIG_UNBLOCK
     136#define SIG_UNBLOCK 0
     137#undef SIG_SETMASK
     138#define SIG_SETMASK 0
     139
     140#undef SA_NOCLDSTOP
     141#define SA_NOCLDSTOP 0
     142#undef SA_ONSTACK
     143#define SA_ONSTACK 0
     144#undef SA_RESETHAND
     145#define SA_RESETHAND 0
     146#undef SA_RESTART
     147#define SA_RESTART 0
     148#undef SA_SIGINFO
     149#define SA_SIGINFO 0
     150#undef SA_NOCLDWAIT
     151#define SA_NOCLDWAIT 0
     152#undef SA_NODEFER
     153#define SA_NODEFER 0
     154
     155#undef SS_ONSTACK
     156#define SS_ONSTACK 0
     157#undef SS_DISABLE
     158#define SS_DISABLE 0
     159
     160#undef MINSIGSTKSZ
     161#define MINSIGSTKSZ 0
     162#undef SIGSTKSZ
     163#define SIGSTKSZ 0
    61164
    62165/* full POSIX set */
    … …  
    92195};
    93196
     197/* Just declared to avoid compiler warnings. */
     198extern int posix_sigemptyset(posix_sigset_t *set);
     199extern int posix_sigprocmask(int how, const posix_sigset_t *restrict set,
     200    posix_sigset_t *restrict oset);
     201
    94202#ifndef LIBPOSIX_INTERNAL
    95203        #define sig_atomic_t posix_sig_atomic_t
     204        #define sigset_t posix_sigset_t
     205        #define sigval posix_sigval
     206        #define sigevent posix_sigevent
     207        #define sigaction posix_sigaction
     208        #define mcontext_t posix_mcontext_t
     209        #define ucontext_t posix_ucontext_t
     210        #define stack_t posix_stack_t
     211        #define siginfo_t posix_siginfo_t
     212        #define sigemptyset posix_sigemptyset
     213        #define sigprocmask posix_sigprocmask
    96214#endif
    97215

  • uspace/lib/posix/stdio.h

    r343d0da1 r10fdd0e  
    4242
    4343/* Character Input/Output */
     44#undef putc
    4445#define putc fputc
     46#undef getc
    4547#define getc fgetc
    4648extern int posix_ungetc(int c, FILE *stream);
    … …  
    6870
    6971/* Temporary Files */
     72#undef L_tmpnam
     73#define L_tmpnam PATH_MAX
     74
    7075extern char *posix_tmpnam(char *s);
    7176

  • uspace/lib/posix/stdlib.c

    r343d0da1 r10fdd0e  
    3737
    3838#include "stdlib.h"
     39#include "libc/sort.h"
     40#include "libc/str.h"
     41#include "libc/vfs/vfs.h"
    3942#include "internal/common.h"
     43#include <errno.h>  // FIXME: use POSIX errno
    4044
    4145/**
    … …  
    5458/**
    5559 *
     60 * @param i Input value.
     61 * @return Absolute value of the parameter.
     62 */
     63int posix_abs(int i)
     64{
     65        return i < 0 ? -i : i;
     66}
     67
     68/**
     69 *
     70 * @param i Input value.
     71 * @return Absolute value of the parameter.
     72 */
     73long posix_labs(long i)
     74{
     75        return i < 0 ? -i : i;
     76}
     77
     78/**
     79 *
     80 * @param i Input value.
     81 * @return Absolute value of the parameter.
     82 */
     83long long posix_llabs(long long i)
     84{
     85        return i < 0 ? -i : i;
     86}
     87
     88posix_div_t posix_div(int numer, int denom)
     89{
     90        return (posix_div_t) { .quot = numer / denom, .rem = numer % denom };
     91}
     92
     93posix_ldiv_t posix_ldiv(long numer, long denom)
     94{
     95        return (posix_ldiv_t) { .quot = numer / denom, .rem = numer % denom };
     96}
     97
     98posix_lldiv_t posix_lldiv(long long numer, long long denom)
     99{
     100        return (posix_lldiv_t) { .quot = numer / denom, .rem = numer % denom };
     101}
     102
     103/**
     104 * Private helper function that serves as a compare function for qsort().
     105 *
     106 * @param elem1 First element to compare.
     107 * @param elem2 Second element to compare.
     108 * @param compare Comparison function without userdata parameter.
     109 *
     110 * @return Relative ordering of the elements.
     111 */
     112static int sort_compare_wrapper(void *elem1, void *elem2, void *userdata)
     113{
     114        int (*compare)(const void *, const void *) = userdata;
     115        return compare(elem1, elem2);
     116}
     117
     118/**
     119 * Array sorting utilizing the quicksort algorithm.
     120 *
    56121 * @param array
    57122 * @param count
    … …  
    59124 * @param compare
    60125 */
    61 int posix_abs(int i)
    62 {
    63         // TODO
    64         not_implemented();
    65 }
    66 
    67 /**
    68  *
    69  * @param array
    70  * @param count
    71  * @param size
    72  * @param compare
    73  */
    74126void posix_qsort(void *array, size_t count, size_t size,
    75127    int (*compare)(const void *, const void *))
    76128{
    77         // TODO
    78         not_implemented();
    79 }
    80 
    81 /**
     129        /* Implemented in libc with one extra argument. */
     130        qsort(array, count, size, sort_compare_wrapper, compare);
     131}
     132
     133/**
     134 * Binary search in a sorted array.
     135 *
     136 * @param key Object to search for.
     137 * @param base Pointer to the first element of the array.
     138 * @param nmemb Number of elements in the array.
     139 * @param size Size of each array element.
     140 * @param compar Comparison function.
     141 * @return Pointer to a matching element, or NULL if none can be found.
     142 */
     143void *posix_bsearch(const void *key, const void *base,
     144    size_t nmemb, size_t size, int (*compar)(const void *, const void *))
     145{
     146        while (nmemb > 0) {
     147                const void *middle = base + (nmemb / 2) * size;
     148                int cmp = compar(key, middle);
     149                if (cmp == 0) {
     150                        return (void *) middle;
     151                }
     152                if (middle == base) {
     153                        /* There is just one member left to check and it
     154                         * didn't match the key. Avoid infinite loop.
     155                         */
     156                        break;
     157                }
     158                if (cmp < 0) {
     159                        nmemb = nmemb / 2;
     160                } else if (cmp > 0) {
     161                        nmemb = nmemb - (nmemb / 2);
     162                        base = middle;
     163                }
     164        }
     165       
     166        return NULL;
     167}
     168
     169/**
     170 * Retrieve a value of the given environment variable.
     171 * Since HelenOS doesn't support env variables at the moment,
     172 * this function always returns NULL.
    82173 *
    83174 * @param name
    84  * @return
     175 * @return Always NULL.
    85176 */
    86177char *posix_getenv(const char *name)
    87178{
    88         // TODO
    89         not_implemented();
     179        return NULL;
    90180}
    91181
    … …  
    103193
    104194/**
     195 *
     196 * @param string String to be passed to a command interpreter.
     197 * @return
     198 */
     199int posix_system(const char *string) {
     200        // TODO: does nothing at the moment
     201        return 0;
     202}
     203
     204/**
    105205 *
    106206 * @param name
    … …  
    110210char *posix_realpath(const char *name, char *resolved)
    111211{
    112         // TODO
    113         not_implemented();
     212        #ifndef PATH_MAX
     213                assert(resolved == NULL);
     214        #endif
     215       
     216        if (name == NULL) {
     217                errno = EINVAL;
     218                return NULL;
     219        }
     220       
     221        // TODO: symlink resolution
     222       
     223        /* Function absolutize is implemented in libc and declared in vfs.h.
     224         * No more processing is required as HelenOS doesn't have symlinks
     225         * so far (as far as I can tell), although this function will need
     226         * to be updated when that support is implemented.
     227         */
     228        char* absolute = absolutize(name, NULL);
     229       
     230        if (absolute == NULL) {
     231                /* POSIX requires some specific errnos to be set
     232                 * for some cases, but there is no way to find out from
     233                 * absolutize().
     234                 */
     235                errno = EINVAL;
     236                return NULL;
     237        }
     238       
     239        if (resolved == NULL) {
     240                return absolute;
     241        } else {
     242                #ifdef PATH_MAX
     243                        str_cpy(resolved, PATH_MAX, absolute);
     244                #endif
     245                free(absolute);
     246                return resolved;
     247        }
    114248}
    115249
    … …  
    119253 *
    120254 * @param nptr
    121  * @param endptr
    122  * @return
    123  */
    124 float posix_strtof(const char *restrict nptr, char **restrict endptr)
    125 {
    126         return (float) posix_strtold(nptr, endptr);
     255 * @return
     256 */
     257double posix_atof(const char *nptr)
     258{
     259        return posix_strtod(nptr, NULL);
    127260}
    128261
    … …  
    135268 * @return
    136269 */
     270float posix_strtof(const char *restrict nptr, char **restrict endptr)
     271{
     272        return (float) posix_strtold(nptr, endptr);
     273}
     274
     275/**
     276 * Converts a string representation of a floating-point number to
     277 * its native representation. See posix_strtold().
     278 *
     279 * @param nptr
     280 * @param endptr
     281 * @return
     282 */
    137283double posix_strtod(const char *restrict nptr, char **restrict endptr)
    138284{
    139285        return (double) posix_strtold(nptr, endptr);
    140 }
    141 
    142 /**
    143  *
    144  * @param str
    145  * @return
    146  */
    147 int posix_atoi(const char *str)
    148 {
    149         // TODO
    150         not_implemented();
    151286}
    152287

  • uspace/lib/posix/stdlib.h

    r343d0da1 r10fdd0e  
    5353/* Absolute Value */
    5454extern int posix_abs(int i);
     55extern long posix_labs(long i);
     56extern long long posix_llabs(long long i);
    5557
    56 /* Array Sort Function */
     58/* Integer division */
     59
     60typedef struct {
     61        int quot, rem;
     62} posix_div_t;
     63
     64typedef struct {
     65        long quot, rem;
     66} posix_ldiv_t;
     67
     68typedef struct {
     69        long long quot, rem;
     70} posix_lldiv_t;
     71
     72extern posix_div_t posix_div(int numer, int denom);
     73extern posix_ldiv_t posix_ldiv(long numer, long denom);
     74extern posix_lldiv_t posix_lldiv(long long numer, long long denom);
     75
     76/* Array Functions */
    5777extern void posix_qsort(void *array, size_t count, size_t size,
    5878    int (*compare)(const void *, const void *));
     79extern void *posix_bsearch(const void *key, const void *base,
     80    size_t nmemb, size_t size, int (*compar)(const void *, const void *));
     81
    5982
    6083/* Environment Access */
    … …  
    6285extern int posix_putenv(char *string);
    6386
     87extern int posix_system(const char *string);
     88
     89
    6490/* Symbolic Links */
    6591extern char *posix_realpath(const char *restrict name, char *restrict resolved);
    6692
    6793/* Floating Point Conversion */
     94extern double posix_atof(const char *nptr);
    6895extern float posix_strtof(const char *restrict nptr, char **restrict endptr);
    6996extern double posix_strtod(const char *restrict nptr, char **restrict endptr);
    … …  
    7198
    7299/* Integer Conversion */
    73 extern int posix_atoi(const char *str);
     100extern int posix_atoi(const char *nptr);
     101extern long int posix_atol(const char *nptr);
     102extern long long int posix_atoll(const char *nptr);
     103
     104extern long int posix_strtol(const char *restrict nptr,
     105    char **restrict endptr, int base);
     106extern long long int posix_strtoll(const char *restrict nptr,
     107    char **restrict endptr, int base);
     108extern unsigned long int posix_strtoul(const char *restrict nptr,
     109    char **restrict endptr, int base);
     110extern unsigned long long int posix_strtoull(
     111    const char *restrict nptr, char **restrict endptr, int base);
     112
    74113
    75114/* Memory Allocation */
    … …  
    86125
    87126        #define abs posix_abs
     127        #define labs posix_labs
     128        #define llabs posix_llabs
     129
     130        #define div_t posix_div_t
     131        #define ldiv_t posix_ldiv_t
     132        #define lldiv_t posix_lldiv_t
     133        #define div posix_div
     134        #define ldiv posix_ldiv
     135        #define lldiv posix_lldiv
    88136
    89137        #define qsort posix_qsort
     138        #define bsearch posix_bsearch
    90139
    91140        #define getenv posix_getenv
     141        #define putenv posix_putenv
     142        #define system posix_system
    92143
    93144        #define realpath posix_realpath
    94145       
     146        #define atof posix_atof
    95147        #define strtof posix_strtof
    96148        #define strtod posix_strtod
    … …  
    98150       
    99151        #define atoi posix_atoi
     152        #define atol posix_atol
     153        #define atoll posix_atoll
     154        #define strtol posix_strtol
     155        #define strtoll posix_strtoll
     156        #define strtoul posix_strtoul
     157        #define strtoull posix_strtoull
    100158
    101159        #define malloc posix_malloc

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

    r343d0da1 r10fdd0e  
    4949typedef sysarg_t posix_dev_t;
    5050
     51/* PThread types */
     52typedef struct posix_thread_attr posix_thread_attr_t;
     53
    5154#ifndef LIBPOSIX_INTERNAL
    5255        #define ino_t posix_ino_t
    … …  
    5962        #define pid_t posix_pid_t
    6063        #define dev_t posix_dev_t
     64       
     65        #define pthread_attr_t posix_thread_attr_t
    6166#endif
    6267
Note: See TracChangeset for help on using the changeset viewer.