Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset fdf97f6 in mainline


Ignore:
Timestamp:
2013-02-25T19:11:50Z (9 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master
Children:
1935591
Parents:
c84f1a4
Message:

Libposix functions are without posix_ prefix

Prior this commit, libposix headers declared all functions as posix_*
and used macros to rename e.g. strncpy to posix_strncpy in all (ported)
sources.

After this change, libposix headers look as normal POSIX compliant headers
(well, almost) and no renaming is done in the source codei (of the ported
applications). Instead, the renaming is done at object files level to
bypass weird problems that are bound to happen if you use macros.

The scheme is following. libposix headers use special macro to declare
the names. When included from outside, the functions have their normal
(standard) names. When included from the libposix sources, posix_ prefix
is added. Thus, when libposix is compiled and linked, it contains the
posix_* naming while compiling of ported software uses the normal
non-prefixed versions. This way the posix_* can use HelenOS libc without
any problem. Before linking, the posix_* prefix is removed from all
symbols and special prefix helenos_libc_ is added to all functions
that exists in our (HelenOS) libc and its name clashes with the POSIX
one.

The following happens, for example, to the open() function that exists in
both libposix and in libc.

  • Headers and sources of libc are left intact.
  • Copy of libc.a is made and to all clashing functions is added the helenos_libc prefix. This library is called libc4posix.a.
  • POSIX_DEF(open)(const char *) is used in libposix headers. This macro expands to plain open when included from the "outside world". But it expands to posix_open when included from libposix sources.
  • Libposix is compiled and linked, containing posix_open() that internally calls open() [the original one from libc].
  • Libposix is transformed - all open() are replaced with prefix variant: helenos_libc_open() and all posix_open() are replaced with open(). The transformed library is stored as libposixaslibc.a

Binutils and PCC are then linked with libc4posix and libposixaslibc
libraries instead of libc and libposix as was done previously.

WARNING: it looks that binutils, PCC and MSIM still works but not all
architectures were tested.

Location:
uspace
Files:
3 added
45 edited

Legend:

Unmodified
Added
Removed
  • uspace/Makefile.common

    rc84f1a4 rfdf97f6  
    227227ifeq ($(POSIX_COMPAT),y)
    228228        CFLAGS = -I$(LIBPOSIX_PREFIX)/include/posix  -I$(LIBPOSIX_PREFIX)/include/
    229         LIBS += $(LIBPOSIX_PREFIX)/libposix.a
     229        BASE_LIBS = $(LIBPOSIX_PREFIX)/libposixaslibc.a $(LIBPOSIX_PREFIX)/libc4posix.a $(LIBSOFTINT_PREFIX)/libsoftint.a
    230230endif
    231231
  • uspace/app/binutils/intrusive.sh

    rc84f1a4 rfdf97f6  
    9696# libposix function name redefinitons in one of the arm-specific files.
    9797#
     98# Patch 9
     99# Libiberty does not trust our strncmp that is provided in libposix.
     100# That is because when cross-compiling, it cannot check how it behaves
     101# and assumes the worst. But then it clashes when linking (due to
     102# multiple definitions of ...) and this patch prevents compilation of
     103# liberty strncmp.
    98104
    99105case "$1" in
     
    157163                # Patch libiberty configure script.
    158164                cat "$2/libiberty/configure.backup" | \
    159                 # See Patch 1.
    160                 sed 's/^cross_compiling=no/cross_compiling=yes/g' \
     165                # See Patch 1 and 9.
     166                sed -e 's/^cross_compiling=no/cross_compiling=yes/g' \
     167                        -e 's/ac_cv_func_strncmp_works=no/ac_cv_func_strncmp_works=yes/g' \
    161168                > "$2/libiberty/configure"
    162169
  • uspace/app/pcc/config.h

    rc84f1a4 rfdf97f6  
    5050
    5151/* Define to 1 if you have the `mkstemp' function. */
    52 //#define HAVE_MKSTEMP 1
     52#define HAVE_MKSTEMP 1
    5353
    5454/* Define to 1 if you have the `snprintf' function. */
  • uspace/lib/posix/Makefile

    rc84f1a4 rfdf97f6  
    3737INCLUDE_LIBC = ./include/libc
    3838
     39LIBC_FILE = $(LIBC_PREFIX)/libc.a
     40
     41FIXED_POSIX_LIBRARY = libposixaslibc.a
     42FIXED_C_LIBRARY = libc4posix.a
     43
     44REDEFS_HIDE_LIBC = redefs-hide-libc.xargs
     45REDEFS_SHOW_LIBPOSIX = redefs-show-posix.xargs
     46COLLISIONS_LIST = collisions.list
     47
    3948PRE_DEPEND = $(INCLUDE_LIBC)
    40 EXTRA_CLEAN = $(INCLUDE_LIBC)
     49EXTRA_CLEAN = \
     50        $(INCLUDE_LIBC) \
     51        $(REDEFS_HIDE_LIBC) $(REDEFS_SHOW_LIBPOSIX) \
     52        $(COLLISIONS_LIST)
     53EXTRA_OUTPUT = $(FIXED_C_LIBRARY) $(FIXED_POSIX_LIBRARY)
    4154
    4255SOURCES = \
     
    6679$(INCLUDE_LIBC): ../c/include
    6780        ln -s -f -n ../$^ $@
     81
     82$(FIXED_C_LIBRARY): $(REDEFS_HIDE_LIBC) $(REDEFS_SHOW_LIBPOSIX)
     83        ./tools/transform-symbols.sh \
     84                $(OBJCOPY) $(AR) echo \
     85                $(LIBC_FILE) $@ \
     86                $(REDEFS_HIDE_LIBC) $(REDEFS_SHOW_LIBPOSIX)
     87
     88$(FIXED_POSIX_LIBRARY): $(LIBRARY).a $(REDEFS_HIDE_LIBC) $(REDEFS_SHOW_LIBPOSIX)
     89        ./tools/transform-symbols.sh \
     90                $(OBJCOPY) $(AR) echo \
     91                $(LIBRARY).a $@ \
     92                $(REDEFS_HIDE_LIBC) $(REDEFS_SHOW_LIBPOSIX)
     93
     94$(REDEFS_HIDE_LIBC): $(COLLISIONS_LIST)
     95        ./tools/create-redefines.sh "" "__helenos_libc_" <$(COLLISIONS_LIST) >$@
     96       
     97$(REDEFS_SHOW_LIBPOSIX): $(COLLISIONS_LIST)
     98        ./tools/create-redefines.sh "posix_" "" <$(COLLISIONS_LIST) >$@
     99
     100$(COLLISIONS_LIST):
     101        ./tools/get-collision-list.sh ./include/posix >$@
  • uspace/lib/posix/include/posix/ctype.h

    rc84f1a4 rfdf97f6  
    3737#define POSIX_CTYPE_H_
    3838
     39#ifndef __POSIX_DEF__
     40#define __POSIX_DEF__(x) x
     41#endif
     42
    3943#include "libc/ctype.h"
    4044
    4145/* Classification of Characters */
    42 extern int posix_isxdigit(int c);
    43 extern int posix_isblank(int c);
    44 extern int posix_iscntrl(int c);
    45 extern int posix_isgraph(int c);
    46 extern int posix_isprint(int c);
    47 extern int posix_ispunct(int c);
     46extern int __POSIX_DEF__(isxdigit)(int c);
     47extern int __POSIX_DEF__(isblank)(int c);
     48extern int __POSIX_DEF__(iscntrl)(int c);
     49extern int __POSIX_DEF__(isgraph)(int c);
     50extern int __POSIX_DEF__(isprint)(int c);
     51extern int __POSIX_DEF__(ispunct)(int c);
    4852
    4953/* Obsolete Functions and Macros */
    50 extern int posix_isascii(int c);
    51 extern int posix_toascii(int c);
     54extern int __POSIX_DEF__(isascii)(int c);
     55extern int __POSIX_DEF__(toascii)(int c);
    5256#undef _tolower
    5357#define _tolower(c) ((c) - 'A' + 'a')
     
    5660
    5761
    58 #ifndef LIBPOSIX_INTERNAL
    59         #define isxdigit posix_isxdigit
    60         #define isblank posix_isblank
    61         #define iscntrl posix_iscntrl
    62         #define isgraph posix_isgraph
    63         #define isprint posix_isprint
    64         #define ispunct posix_ispunct
    65        
    66         #define isascii posix_isascii
    67         #define toascii posix_toascii
    68 #endif
    6962
    7063#endif /* POSIX_CTYPE_H_ */
  • uspace/lib/posix/include/posix/fcntl.h

    rc84f1a4 rfdf97f6  
    3636#define POSIX_FCNTL_H_
    3737
     38#ifndef __POSIX_DEF__
     39#define __POSIX_DEF__(x) x
     40#endif
     41
    3842#include "sys/types.h"
    3943#include "libc/fcntl.h"
     
    7276#define FD_CLOEXEC         1 /* Close on exec. */
    7377
    74 extern int posix_open(const char *pathname, int flags, ...);
    75 extern int posix_fcntl(int fd, int cmd, ...);
     78extern int __POSIX_DEF__(open)(const char *pathname, int flags, ...);
     79extern int __POSIX_DEF__(fcntl)(int fd, int cmd, ...);
    7680
    77 #ifndef LIBPOSIX_INTERNAL
    78         #define fcntl posix_fcntl
    79         #define open posix_open
    80 #endif
    8181
    8282#endif /* POSIX_FCNTL_H_ */
  • uspace/lib/posix/include/posix/fnmatch.h

    rc84f1a4 rfdf97f6  
    3636#define POSIX_FNMATCH_H_
    3737
     38#ifndef __POSIX_DEF__
     39#define __POSIX_DEF__(x) x
     40#endif
     41
    3842/* Error Values */
    3943#undef FNM_NOMATCH
     
    5660#define FNM_CASEFOLD 16
    5761
    58 extern int posix_fnmatch(const char *pattern, const char *string, int flags);
     62extern int __POSIX_DEF__(fnmatch)(const char *pattern, const char *string, int flags);
    5963
    60 #ifndef LIBPOSIX_INTERNAL
    61         #define fnmatch posix_fnmatch
    62 #endif
    6364
    6465#endif /* POSIX_FNMATCH_H_ */
  • uspace/lib/posix/include/posix/getopt.h

    rc84f1a4 rfdf97f6  
    3535#define POSIX_GETOPT_H
    3636
     37#ifndef __POSIX_DEF__
     38#define __POSIX_DEF__(x) x
     39#endif
     40
    3741#include "unistd.h"
    3842
     
    5155#endif
    5256
    53 extern int posix_getopt_long(int, char * const [], const char *, const struct option *, int *);
    54 
    55 
    56 #ifndef LIBPOSIX_INTERNAL
    57         #define getopt_long posix_getopt_long
    58 #endif
     57extern int __POSIX_DEF__(getopt_long)(int, char * const [], const char *, const struct option *, int *);
    5958
    6059
  • uspace/lib/posix/include/posix/inttypes.h

    rc84f1a4 rfdf97f6  
    3636#define POSIX_INTTYPES_H_
    3737
     38#ifndef __POSIX_DEF__
     39#define __POSIX_DEF__(x) x
     40#endif
     41
    3842#include "stdint.h"
    3943#include "libc/inttypes.h"
    4044
    41 extern posix_intmax_t posix_strtoimax(const char *restrict nptr,
     45extern __POSIX_DEF__(intmax_t) __POSIX_DEF__(strtoimax)(const char *restrict nptr,
    4246    char **restrict endptr, int base);
    43 extern posix_uintmax_t posix_strtoumax(const char *restrict nptr,
     47extern __POSIX_DEF__(uintmax_t) __POSIX_DEF__(strtoumax)(const char *restrict nptr,
    4448    char **restrict endptr, int base);
    4549
    46 #ifndef LIBPOSIX_INTERNAL
    47         #define strtoimax posix_strtoimax
    48         #define strtoumax posix_strtoumax
    49 #endif
    5050
    5151#endif /* POSIX_INTTYPES_H_ */
  • uspace/lib/posix/include/posix/locale.h

    rc84f1a4 rfdf97f6  
    3636#define POSIX_LOCALE_H_
    3737
     38#ifndef __POSIX_DEF__
     39#define __POSIX_DEF__(x) x
     40#endif
     41
    3842#ifndef NULL
    3943        #define NULL ((void *) 0)
     
    4246#ifndef __locale_t_defined
    4347        #define __locale_t_defined
    44         typedef struct __posix_locale *posix_locale_t;
     48        typedef struct __posix_locale *__POSIX_DEF__(locale_t);
    4549        #ifndef LIBPOSIX_INTERNAL
    46                 #define locale_t posix_locale_t
     50                #define locale_t __POSIX_DEF__(locale_t)
    4751        #endif
    4852#endif
     
    8286#define LC_GLOBAL_LOCALE NULL
    8387
    84 struct posix_lconv {
     88struct __POSIX_DEF__(lconv) {
    8589        char *currency_symbol;
    8690        char *decimal_point;
     
    109113};
    110114
    111 extern char *posix_setlocale(int category, const char *locale);
    112 extern struct posix_lconv *posix_localeconv(void);
     115extern char *__POSIX_DEF__(setlocale)(int category, const char *locale);
     116extern struct __POSIX_DEF__(lconv) *__POSIX_DEF__(localeconv)(void);
    113117
    114118/* POSIX Extensions */
    115 extern posix_locale_t posix_duplocale(posix_locale_t locobj);
    116 extern void posix_freelocale(posix_locale_t locobj);
    117 extern posix_locale_t posix_newlocale(int category_mask, const char *locale,
    118     posix_locale_t base);
    119 extern posix_locale_t posix_uselocale(posix_locale_t newloc);
     119extern __POSIX_DEF__(locale_t) __POSIX_DEF__(duplocale)(__POSIX_DEF__(locale_t) locobj);
     120extern void __POSIX_DEF__(freelocale)(__POSIX_DEF__(locale_t) locobj);
     121extern __POSIX_DEF__(locale_t) __POSIX_DEF__(newlocale)(int category_mask, const char *locale,
     122    __POSIX_DEF__(locale_t) base);
     123extern __POSIX_DEF__(locale_t) __POSIX_DEF__(uselocale)(__POSIX_DEF__(locale_t) newloc);
    120124
    121 #ifndef LIBPOSIX_INTERNAL
    122         #define lconv posix_lconv
    123 
    124         #define setlocale posix_setlocale
    125         #define localeconv posix_localeconv
    126 
    127         #define newlocale posix_newlocale
    128         #define uselocale posix_uselocale
    129         #define duplocale posix_duplocale
    130         #define freelocale posix_freelocale
    131 #endif
    132125
    133126#endif /* POSIX_LOCALE_H_ */
  • uspace/lib/posix/include/posix/math.h

    rc84f1a4 rfdf97f6  
    3636#define POSIX_MATH_H_
    3737
     38#ifndef __POSIX_DEF__
     39#define __POSIX_DEF__(x) x
     40#endif
     41
    3842/* Normalization Functions */
    39 extern double posix_ldexp(double x, int exp);
    40 extern double posix_frexp(double num, int *exp);
     43extern double __POSIX_DEF__(ldexp)(double x, int exp);
     44extern double __POSIX_DEF__(frexp)(double num, int *exp);
    4145
    42 #ifndef LIBPOSIX_INTERNAL
    43         #define ldexp posix_ldexp
    44         #define frexp posix_frexp
    45 #endif
    4646
    4747#endif /* POSIX_MATH_H_ */
  • uspace/lib/posix/include/posix/pwd.h

    rc84f1a4 rfdf97f6  
    3636#define POSIX_PWD_H_
    3737
     38#ifndef __POSIX_DEF__
     39#define __POSIX_DEF__(x) x
     40#endif
     41
    3842#include "sys/types.h"
    3943
    40 struct posix_passwd {
     44struct __POSIX_DEF__(passwd) {
    4145        char *pw_name;
    42         posix_uid_t pw_uid;
    43         posix_gid_t pw_gid;
     46        __POSIX_DEF__(uid_t) pw_uid;
     47        __POSIX_DEF__(gid_t) pw_gid;
    4448        char *pw_dir;
    4549        char *pw_shell;
    4650};
    4751
    48 extern struct posix_passwd *posix_getpwent(void);
    49 extern void posix_setpwent(void);
    50 extern void posix_endpwent(void);
     52extern struct __POSIX_DEF__(passwd) *__POSIX_DEF__(getpwent)(void);
     53extern void __POSIX_DEF__(setpwent)(void);
     54extern void __POSIX_DEF__(endpwent)(void);
    5155
    52 extern struct posix_passwd *posix_getpwnam(const char *name);
    53 extern int posix_getpwnam_r(const char *name, struct posix_passwd *pwd,
    54     char *buffer, size_t bufsize, struct posix_passwd **result);
     56extern struct __POSIX_DEF__(passwd) *__POSIX_DEF__(getpwnam)(const char *name);
     57extern int __POSIX_DEF__(getpwnam_r)(const char *name, struct __POSIX_DEF__(passwd) *pwd,
     58    char *buffer, size_t bufsize, struct __POSIX_DEF__(passwd) **result);
    5559
    56 extern struct posix_passwd *posix_getpwuid(posix_uid_t uid);
    57 extern int posix_getpwuid_r(posix_uid_t uid, struct posix_passwd *pwd,
    58     char *buffer, size_t bufsize, struct posix_passwd **result);
     60extern struct __POSIX_DEF__(passwd) *__POSIX_DEF__(getpwuid)(__POSIX_DEF__(uid_t) uid);
     61extern int __POSIX_DEF__(getpwuid_r)(__POSIX_DEF__(uid_t) uid, struct __POSIX_DEF__(passwd) *pwd,
     62    char *buffer, size_t bufsize, struct __POSIX_DEF__(passwd) **result);
    5963
    60 #ifndef LIBPOSIX_INTERNAL
    61         #define passwd posix_passwd
    62        
    63         #define getpwent posix_getpwent
    64         #define setpwent posix_setpwent
    65         #define endpwent posix_endpwent
    66 
    67         #define getpwnam posix_getpwnam
    68         #define getpwnam_r posix_getpwnam_r
    69 
    70         #define getpwuid posix_getpwuid
    71         #define getpwuid_r posix_getpwuid_r
    72 #endif
    7364
    7465#endif /* POSIX_PWD_H_ */
  • uspace/lib/posix/include/posix/signal.h

    rc84f1a4 rfdf97f6  
    3636#define POSIX_SIGNAL_H_
    3737
     38#ifndef __POSIX_DEF__
     39#define __POSIX_DEF__(x) x
     40#endif
     41
    3842#include "sys/types.h"
    3943
     
    5155#define SIG_IGN ((void (*)(int)) __posix_ignore_signal_handler)
    5256
    53 typedef int posix_sig_atomic_t;
    54 typedef uint32_t posix_sigset_t;
    55 typedef struct posix_mcontext {
     57typedef int __POSIX_DEF__(sig_atomic_t);
     58typedef uint32_t __POSIX_DEF__(sigset_t);
     59typedef struct __POSIX_DEF__(mcontext) {
    5660        /* must not be empty to avoid compiler warnings (-pedantic) */
    5761        int dummy;
    58 } posix_mcontext_t;
    59 
    60 union posix_sigval {
     62} __POSIX_DEF__(mcontext_t);
     63
     64union __POSIX_DEF__(sigval) {
    6165        int sival_int;
    6266        void *sival_ptr;
    6367};
    6468
    65 struct posix_sigevent {
     69struct __POSIX_DEF__(sigevent) {
    6670        int sigev_notify; /* Notification type. */
    6771        int sigev_signo; /* Signal number. */
    68         union posix_sigval sigev_value; /* Signal value. */
    69         void (*sigev_notify_function)(union posix_sigval); /* Notification function. */
    70         posix_thread_attr_t *sigev_notify_attributes; /* Notification attributes. */
     72        union __POSIX_DEF__(sigval) sigev_value; /* Signal value. */
     73        void (*sigev_notify_function)(union __POSIX_DEF__(sigval)); /* Notification function. */
     74        __POSIX_DEF__(thread_attr_t) *sigev_notify_attributes; /* Notification attributes. */
    7175};
    7276
     
    7781        int si_errno;
    7882
    79         posix_pid_t si_pid;
    80         posix_uid_t si_uid;
     83        __POSIX_DEF__(pid_t) si_pid;
     84        __POSIX_DEF__(uid_t) si_uid;
    8185        void *si_addr;
    8286        int si_status;
     
    8488        long si_band;
    8589
    86         union posix_sigval si_value;
    87 } posix_siginfo_t;
    88 
    89 struct posix_sigaction {
     90        union __POSIX_DEF__(sigval) si_value;
     91} __POSIX_DEF__(siginfo_t);
     92
     93struct __POSIX_DEF__(sigaction) {
    9094        void (*sa_handler)(int);
    91         posix_sigset_t sa_mask;
     95        __POSIX_DEF__(sigset_t) sa_mask;
    9296        int sa_flags;
    93         void (*sa_sigaction)(int, posix_siginfo_t *, void *);
     97        void (*sa_sigaction)(int, __POSIX_DEF__(siginfo_t) *, void *);
    9498};
    9599
     
    98102        size_t ss_size;
    99103        int ss_flags;
    100 } posix_stack_t;
    101 
    102 typedef struct posix_ucontext {
    103         struct posix_ucontext *uc_link;
    104         posix_sigset_t uc_sigmask;
    105         posix_stack_t uc_stack;
    106         posix_mcontext_t uc_mcontext;
    107 } posix_ucontext_t;
    108 
    109 /* Values of posix_sigevent::sigev_notify */
     104} __POSIX_DEF__(stack_t);
     105
     106typedef struct __POSIX_DEF__(ucontext) {
     107        struct __POSIX_DEF__(ucontext) *uc_link;
     108        __POSIX_DEF__(sigset_t) uc_sigmask;
     109        __POSIX_DEF__(stack_t) uc_stack;
     110        __POSIX_DEF__(mcontext_t) uc_mcontext;
     111} __POSIX_DEF__(ucontext_t);
     112
     113/* Values of __POSIX_DEF__(sigevent)::sigev_notify */
    110114#undef SIGEV_NONE
    111115#undef SIGEV_SIGNAL
     
    255259};
    256260
    257 extern int posix_sigaction(int sig, const struct posix_sigaction *restrict act,
    258     struct posix_sigaction *restrict oact);
    259 
    260 extern void (*posix_signal(int sig, void (*func)(int)))(int);
    261 extern int posix_raise(int sig);
    262 extern int posix_kill(posix_pid_t pid, int sig);
    263 extern int posix_killpg(posix_pid_t pid, int sig);
    264 
    265 extern void posix_psiginfo(const posix_siginfo_t *pinfo, const char *message);
    266 extern void posix_psignal(int signum, const char *message);
    267 
    268 extern int posix_sigemptyset(posix_sigset_t *set);
    269 extern int posix_sigfillset(posix_sigset_t *set);
    270 extern int posix_sigaddset(posix_sigset_t *set, int signo);
    271 extern int posix_sigdelset(posix_sigset_t *set, int signo);
    272 extern int posix_sigismember(const posix_sigset_t *set, int signo);
    273 
    274 extern int posix_thread_sigmask(int how, const posix_sigset_t *restrict set,
    275     posix_sigset_t *restrict oset);
    276 extern int posix_sigprocmask(int how, const posix_sigset_t *restrict set,
    277     posix_sigset_t *restrict oset);
    278 
    279 #ifndef LIBPOSIX_INTERNAL
    280         #define sig_atomic_t posix_sig_atomic_t
    281         #define sigset_t posix_sigset_t
    282         #define sigval posix_sigval
    283         #ifndef sigevent
    284                 #define sigevent posix_sigevent
    285         #endif
    286         #define mcontext_t posix_mcontext_t
    287         #define ucontext_t posix_ucontext_t
    288         #define stack_t posix_stack_t
    289         #define siginfo_t posix_siginfo_t
    290 
    291         #define sigaction posix_sigaction
    292 
    293         #define signal posix_signal
    294         #define raise posix_raise
    295         #define kill posix_kill
    296         #define killpg posix_killpg
    297 
    298         #define psiginfo posix_psiginfo
    299         #define psignal posix_psignal
    300 
    301         #define sigemptyset posix_sigemptyset
    302         #define sigfillset posix_sigfillset
    303         #define sigaddset posix_sigaddset
    304         #define sigdelset posix_sigdelset
    305         #define sigismember posix_sigismember
    306 
    307         #define pthread_sigmask posix_thread_sigmask
    308         #define sigprocmask posix_sigprocmask
    309 #endif
     261extern int __POSIX_DEF__(sigaction)(int sig, const struct __POSIX_DEF__(sigaction) *restrict act,
     262    struct __POSIX_DEF__(sigaction) *restrict oact);
     263
     264extern void (*__POSIX_DEF__(signal)(int sig, void (*func)(int)))(int);
     265extern int __POSIX_DEF__(raise)(int sig);
     266extern int __POSIX_DEF__(kill)(__POSIX_DEF__(pid_t) pid, int sig);
     267extern int __POSIX_DEF__(killpg)(__POSIX_DEF__(pid_t) pid, int sig);
     268
     269extern void __POSIX_DEF__(psiginfo)(const __POSIX_DEF__(siginfo_t) *pinfo, const char *message);
     270extern void __POSIX_DEF__(psignal)(int signum, const char *message);
     271
     272extern int __POSIX_DEF__(sigemptyset)(__POSIX_DEF__(sigset_t) *set);
     273extern int __POSIX_DEF__(sigfillset)(__POSIX_DEF__(sigset_t) *set);
     274extern int __POSIX_DEF__(sigaddset)(__POSIX_DEF__(sigset_t) *set, int signo);
     275extern int __POSIX_DEF__(sigdelset)(__POSIX_DEF__(sigset_t) *set, int signo);
     276extern int __POSIX_DEF__(sigismember)(const __POSIX_DEF__(sigset_t) *set, int signo);
     277
     278extern int __POSIX_DEF__(thread_sigmask)(int how, const __POSIX_DEF__(sigset_t) *restrict set,
     279    __POSIX_DEF__(sigset_t) *restrict oset);
     280extern int __POSIX_DEF__(sigprocmask)(int how, const __POSIX_DEF__(sigset_t) *restrict set,
     281    __POSIX_DEF__(sigset_t) *restrict oset);
     282
    310283
    311284#endif /* POSIX_SIGNAL_H_ */
  • uspace/lib/posix/include/posix/stddef.h

    rc84f1a4 rfdf97f6  
    3636#define POSIX_STDDEF_H_
    3737
     38#ifndef __POSIX_DEF__
     39#define __POSIX_DEF__(x) x
     40#endif
     41
    3842#include "sys/types.h"
    3943
     
    4448#define offsetof(type,member) ((size_t) &(((type *) 0)->member))
    4549
    46 typedef ssize_t posix_ptrdiff_t;
     50typedef ssize_t __POSIX_DEF__(ptrdiff_t);
    4751
    48 #ifndef LIBPOSIX_INTERNAL
    49         #define ptrdiff_t posix_ptrdiff_t
    50 #endif
    5152
    5253#endif /* POSIX_STDDEF_H_ */
  • uspace/lib/posix/include/posix/stdint.h

    rc84f1a4 rfdf97f6  
    3535#ifndef POSIX_STDINT_H_
    3636#define POSIX_STDINT_H_
     37
     38#ifndef __POSIX_DEF__
     39#define __POSIX_DEF__(x) x
     40#endif
    3741
    3842#include "libc/stdint.h"
     
    100104#include "libc/sys/types.h"
    101105
    102 typedef int64_t posix_intmax_t;
    103 typedef uint64_t posix_uintmax_t;
     106typedef int64_t __POSIX_DEF__(intmax_t);
     107typedef uint64_t __POSIX_DEF__(uintmax_t);
    104108
    105 #ifndef LIBPOSIX_INTERNAL
    106         #define intmax_t posix_intmax_t
    107         #define uintmax_t posix_uintmax_t
    108 #endif
    109109
    110110#endif /* POSIX_STDINT_H_ */
  • uspace/lib/posix/include/posix/stdio.h

    rc84f1a4 rfdf97f6  
    3737#define POSIX_STDIO_H_
    3838
     39#ifndef __POSIX_DEF__
     40#define __POSIX_DEF__(x) x
     41/* DEBUG macro does not belong to POSIX stdio.h. Its unconditional
     42 * definition in the native stdio.h causes unexpected behaviour of
     43 * applications which uses their own DEBUG macro (e.g. debugging
     44 * output is printed even if not desirable). */
     45#undef DEBUG
     46#endif
     47
    3948#include "stddef.h"
    4049#include "unistd.h"
     
    97106extern size_t fwrite(const void *, size_t, size_t, FILE *);
    98107
    99 extern int fseek(FILE *, off64_t, int);
    100108extern void rewind(FILE *);
    101 extern off64_t ftell(FILE *);
    102109extern int feof(FILE *);
    103110extern int fileno(FILE *);
     
    115122#undef L_ctermid
    116123#define L_ctermid PATH_MAX
    117 extern char *posix_ctermid(char *s);
     124extern char *__POSIX_DEF__(ctermid)(char *s);
    118125
    119126/* Error Recovery */
    120 extern void posix_clearerr(FILE *stream);
     127extern void __POSIX_DEF__(clearerr)(FILE *stream);
    121128
    122129/* Input/Output */
    123130#undef putc
    124131#define putc fputc
    125 extern int posix_fputs(const char *restrict s, FILE *restrict stream);
     132extern int __POSIX_DEF__(fputs)(const char *restrict s, FILE *restrict stream);
    126133#undef getc
    127134#define getc fgetc
    128 extern int posix_ungetc(int c, FILE *stream);
    129 extern ssize_t posix_getdelim(char **restrict lineptr, size_t *restrict n,
     135extern int __POSIX_DEF__(ungetc)(int c, FILE *stream);
     136extern ssize_t __POSIX_DEF__(getdelim)(char **restrict lineptr, size_t *restrict n,
    130137    int delimiter, FILE *restrict stream);
    131 extern ssize_t posix_getline(char **restrict lineptr, size_t *restrict n,
     138extern ssize_t __POSIX_DEF__(getline)(char **restrict lineptr, size_t *restrict n,
    132139    FILE *restrict stream);
    133140
    134141/* Opening Streams */
    135 extern FILE *posix_freopen(const char *restrict filename,
     142extern FILE *__POSIX_DEF__(freopen)(const char *restrict filename,
    136143    const char *restrict mode, FILE *restrict stream);
    137144
    138145/* Error Messages */
    139 extern void posix_perror(const char *s);
     146extern void __POSIX_DEF__(perror)(const char *s);
    140147
    141148/* File Positioning */
    142 typedef struct _posix_fpos posix_fpos_t;
    143 extern int posix_fsetpos(FILE *stream, const posix_fpos_t *pos);
    144 extern int posix_fgetpos(FILE *restrict stream, posix_fpos_t *restrict pos);
    145 extern int posix_fseek(FILE *stream, long offset, int whence);
    146 extern int posix_fseeko(FILE *stream, posix_off_t offset, int whence);
    147 extern long posix_ftell(FILE *stream);
    148 extern posix_off_t posix_ftello(FILE *stream);
     149typedef struct _posix_fpos __POSIX_DEF__(fpos_t);
     150extern int __POSIX_DEF__(fsetpos)(FILE *stream, const __POSIX_DEF__(fpos_t) *pos);
     151extern int __POSIX_DEF__(fgetpos)(FILE *restrict stream, __POSIX_DEF__(fpos_t) *restrict pos);
     152extern int __POSIX_DEF__(fseek)(FILE *stream, long offset, int whence);
     153extern int __POSIX_DEF__(fseeko)(FILE *stream, __POSIX_DEF__(off_t) offset, int whence);
     154extern long __POSIX_DEF__(ftell)(FILE *stream);
     155extern __POSIX_DEF__(off_t) __POSIX_DEF__(ftello)(FILE *stream);
    149156
    150157/* Flushing Buffers */
    151 extern int posix_fflush(FILE *stream);
     158extern int __POSIX_DEF__(fflush)(FILE *stream);
    152159
    153160/* Formatted Output */
    154 extern int posix_dprintf(int fildes, const char *restrict format, ...)
     161extern int __POSIX_DEF__(dprintf)(int fildes, const char *restrict format, ...)
    155162    PRINTF_ATTRIBUTE(2, 3);
    156 extern int posix_vdprintf(int fildes, const char *restrict format, va_list ap);
    157 extern int posix_sprintf(char *restrict s, const char *restrict format, ...)
     163extern int __POSIX_DEF__(vdprintf)(int fildes, const char *restrict format, va_list ap);
     164extern int __POSIX_DEF__(sprintf)(char *restrict s, const char *restrict format, ...)
    158165    PRINTF_ATTRIBUTE(2, 3);
    159 extern int posix_vsprintf(char *restrict s, const char *restrict format, va_list ap);
     166extern int __POSIX_DEF__(vsprintf)(char *restrict s, const char *restrict format, va_list ap);
    160167
    161168/* Formatted Input */
    162 extern int posix_fscanf(
     169extern int __POSIX_DEF__(fscanf)(
    163170    FILE *restrict stream, const char *restrict format, ...);
    164 extern int posix_vfscanf(
     171extern int __POSIX_DEF__(vfscanf)(
    165172    FILE *restrict stream, const char *restrict format, va_list arg);
    166 extern int posix_scanf(const char *restrict format, ...);
    167 extern int posix_vscanf(const char *restrict format, va_list arg);
    168 extern int posix_sscanf(
     173extern int __POSIX_DEF__(scanf)(const char *restrict format, ...);
     174extern int __POSIX_DEF__(vscanf)(const char *restrict format, va_list arg);
     175extern int __POSIX_DEF__(sscanf)(
    169176    const char *restrict s, const char *restrict format, ...);
    170 extern int posix_vsscanf(
     177extern int __POSIX_DEF__(vsscanf)(
    171178    const char *restrict s, const char *restrict format, va_list arg);
    172179
    173180/* File Locking */
    174 extern void posix_flockfile(FILE *file);
    175 extern int posix_ftrylockfile(FILE *file);
    176 extern void posix_funlockfile(FILE *file);
    177 extern int posix_getc_unlocked(FILE *stream);
    178 extern int posix_getchar_unlocked(void);
    179 extern int posix_putc_unlocked(int c, FILE *stream);
    180 extern int posix_putchar_unlocked(int c);
     181extern void __POSIX_DEF__(flockfile)(FILE *file);
     182extern int __POSIX_DEF__(ftrylockfile)(FILE *file);
     183extern void __POSIX_DEF__(funlockfile)(FILE *file);
     184extern int __POSIX_DEF__(getc_unlocked)(FILE *stream);
     185extern int __POSIX_DEF__(getchar_unlocked)(void);
     186extern int __POSIX_DEF__(putc_unlocked)(int c, FILE *stream);
     187extern int __POSIX_DEF__(putchar_unlocked)(int c);
    181188
    182189/* Deleting Files */
    183 extern int posix_remove(const char *path);
     190extern int __POSIX_DEF__(remove)(const char *path);
    184191
    185192/* Renaming Files */
    186 extern int posix_rename(const char *old, const char *new);
     193extern int __POSIX_DEF__(rename)(const char *old, const char *new);
    187194
    188195/* Temporary Files */
    189196#undef L_tmpnam
    190197#define L_tmpnam PATH_MAX
    191 extern char *posix_tmpnam(char *s);
    192 extern char *posix_tempnam(const char *dir, const char *pfx);
    193 extern FILE *posix_tmpfile(void);
    194 
    195 #ifndef LIBPOSIX_INTERNAL
    196         /* DEBUG macro does not belong to POSIX stdio.h. Its unconditional
    197          * definition in the native stdio.h causes unexpected behaviour of
    198          * applications which uses their own DEBUG macro (e.g. debugging
    199          * output is printed even if not desirable). */
    200         #undef DEBUG
    201 
    202         #define ctermid posix_ctermid
    203 
    204         #define clearerr posix_clearerr
    205 
    206         #define fputs posix_fputs
    207         #define ungetc posix_ungetc
    208         #define getdelim posix_getdelim
    209         #define getline posix_getline
    210 
    211         #define freopen posix_freopen
    212 
    213         #define perror posix_perror
    214 
    215         #define fpos_t posix_fpos_t
    216         #define fsetpos posix_fsetpos
    217         #define fgetpos posix_fgetpos
    218         #define fseek posix_fseek
    219         #define fseeko posix_fseeko
    220         #define ftell posix_ftell
    221         #define ftello posix_ftello
    222 
    223         #define fflush posix_fflush
    224 
    225         #define dprintf posix_dprintf
    226         #define vdprintf posix_vdprintf
    227         #define sprintf posix_sprintf
    228         #define vsprintf posix_vsprintf
    229 
    230         #define fscanf posix_fscanf
    231         #define vfscanf posix_vfscanf
    232         #define vscanf posix_vscanf
    233         #define scanf posix_scanf
    234         #define sscanf posix_sscanf
    235         #define vsscanf posix_vsscanf
    236 
    237         #define flockfile posix_flockfile
    238         #define ftrylockfile posix_ftrylockfile
    239         #define funlockfile posix_funlockfile
    240 
    241         #define getc_unlocked posix_getc_unlocked
    242         #define getchar_unlocked posix_getchar_unlocked
    243         #define putc_unlocked posix_putc_unlocked
    244         #define putchar_unlocked posix_putchar_unlocked
    245 
    246         #define remove posix_remove
    247 
    248         #define rename posix_rename
    249 
    250         #define tmpnam posix_tmpnam
    251         #define tempnam posix_tempnam
    252         #define tmpfile posix_tmpfile
    253 #endif
     198extern char *__POSIX_DEF__(tmpnam)(char *s);
     199extern char *__POSIX_DEF__(tempnam)(const char *dir, const char *pfx);
     200extern FILE *__POSIX_DEF__(tmpfile)(void);
     201
    254202
    255203#endif /* POSIX_STDIO_H_ */
  • uspace/lib/posix/include/posix/stdlib.h

    rc84f1a4 rfdf97f6  
    3737#define POSIX_STDLIB_H_
    3838
     39#ifndef __POSIX_DEF__
     40#define __POSIX_DEF__(x) x
     41#endif
     42
    3943#include "sys/types.h"
    4044
     
    4953#define EXIT_SUCCESS 0
    5054#define _Exit exit
    51 extern int posix_atexit(void (*func)(void));
     55extern int __POSIX_DEF__(atexit)(void (*func)(void));
    5256extern void exit(int status);
    5357extern void abort(void) __attribute__((noreturn));
    5458
    5559/* Absolute Value */
    56 extern int posix_abs(int i);
    57 extern long posix_labs(long i);
    58 extern long long posix_llabs(long long i);
     60extern int __POSIX_DEF__(abs)(int i);
     61extern long __POSIX_DEF__(labs)(long i);
     62extern long long __POSIX_DEF__(llabs)(long long i);
    5963
    6064/* Integer Division */
     
    6266typedef struct {
    6367        int quot, rem;
    64 } posix_div_t;
     68} __POSIX_DEF__(div_t);
    6569
    6670typedef struct {
    6771        long quot, rem;
    68 } posix_ldiv_t;
     72} __POSIX_DEF__(ldiv_t);
    6973
    7074typedef struct {
    7175        long long quot, rem;
    72 } posix_lldiv_t;
     76} __POSIX_DEF__(lldiv_t);
    7377
    74 extern posix_div_t posix_div(int numer, int denom);
    75 extern posix_ldiv_t posix_ldiv(long numer, long denom);
    76 extern posix_lldiv_t posix_lldiv(long long numer, long long denom);
     78extern __POSIX_DEF__(div_t) __POSIX_DEF__(div)(int numer, int denom);
     79extern __POSIX_DEF__(ldiv_t) __POSIX_DEF__(ldiv)(long numer, long denom);
     80extern __POSIX_DEF__(lldiv_t) __POSIX_DEF__(lldiv)(long long numer, long long denom);
    7781
    7882/* Array Functions */
    79 extern void posix_qsort(void *array, size_t count, size_t size,
     83extern void __POSIX_DEF__(qsort)(void *array, size_t count, size_t size,
    8084    int (*compare)(const void *, const void *));
    81 extern void *posix_bsearch(const void *key, const void *base,
     85extern void *__POSIX_DEF__(bsearch)(const void *key, const void *base,
    8286    size_t nmemb, size_t size, int (*compar)(const void *, const void *));
    8387
    8488/* Environment Access */
    85 extern char *posix_getenv(const char *name);
    86 extern int posix_putenv(char *string);
    87 extern int posix_system(const char *string);
     89extern char *__POSIX_DEF__(getenv)(const char *name);
     90extern int __POSIX_DEF__(putenv)(char *string);
     91extern int __POSIX_DEF__(system)(const char *string);
    8892
    8993/* Symbolic Links */
    90 extern char *posix_realpath(const char *restrict name, char *restrict resolved);
     94extern char *__POSIX_DEF__(realpath)(const char *restrict name, char *restrict resolved);
    9195
    9296/* Floating Point Conversion */
    93 extern double posix_atof(const char *nptr);
    94 extern float posix_strtof(const char *restrict nptr, char **restrict endptr);
    95 extern double posix_strtod(const char *restrict nptr, char **restrict endptr);
    96 extern long double posix_strtold(const char *restrict nptr, char **restrict endptr);
     97extern double __POSIX_DEF__(atof)(const char *nptr);
     98extern float __POSIX_DEF__(strtof)(const char *restrict nptr, char **restrict endptr);
     99extern double __POSIX_DEF__(strtod)(const char *restrict nptr, char **restrict endptr);
     100extern long double __POSIX_DEF__(strtold)(const char *restrict nptr, char **restrict endptr);
    97101
    98102/* Integer Conversion */
    99 extern int posix_atoi(const char *nptr);
    100 extern long int posix_atol(const char *nptr);
    101 extern long long int posix_atoll(const char *nptr);
    102 extern long int posix_strtol(const char *restrict nptr,
     103extern int __POSIX_DEF__(atoi)(const char *nptr);
     104extern long int __POSIX_DEF__(atol)(const char *nptr);
     105extern long long int __POSIX_DEF__(atoll)(const char *nptr);
     106extern long int __POSIX_DEF__(strtol)(const char *restrict nptr,
    103107    char **restrict endptr, int base);
    104 extern long long int posix_strtoll(const char *restrict nptr,
     108extern long long int __POSIX_DEF__(strtoll)(const char *restrict nptr,
    105109    char **restrict endptr, int base);
    106 extern unsigned long int posix_strtoul(const char *restrict nptr,
     110extern unsigned long int __POSIX_DEF__(strtoul)(const char *restrict nptr,
    107111    char **restrict endptr, int base);
    108 extern unsigned long long int posix_strtoull(
     112extern unsigned long long int __POSIX_DEF__(strtoull)(
    109113    const char *restrict nptr, char **restrict endptr, int base);
    110114
    111115/* Memory Allocation */
    112 extern void *posix_malloc(size_t size);
    113 extern void *posix_calloc(size_t nelem, size_t elsize);
    114 extern void *posix_realloc(void *ptr, size_t size);
    115 extern void posix_free(void *ptr);
     116extern void *__POSIX_DEF__(malloc)(size_t size);
     117extern void *__POSIX_DEF__(calloc)(size_t nelem, size_t elsize);
     118extern void *__POSIX_DEF__(realloc)(void *ptr, size_t size);
     119extern void __POSIX_DEF__(free)(void *ptr);
    116120
    117121/* Temporary Files */
    118 extern int posix_mkstemp(char *tmpl);
     122extern int __POSIX_DEF__(mkstemp)(char *tmpl);
    119123
    120124/* Legacy Declarations */
    121 extern char *posix_mktemp(char *tmpl);
     125extern char *__POSIX_DEF__(mktemp)(char *tmpl);
    122126extern int bsd_getloadavg(double loadavg[], int nelem);
    123 
    124 #ifndef LIBPOSIX_INTERNAL
    125         #define atexit posix_atexit
    126 
    127         #define abs posix_abs
    128         #define labs posix_labs
    129         #define llabs posix_llabs
    130 
    131         #define div_t posix_div_t
    132         #define ldiv_t posix_ldiv_t
    133         #define lldiv_t posix_lldiv_t
    134         #define div posix_div
    135         #define ldiv posix_ldiv
    136         #define lldiv posix_lldiv
    137 
    138         #define qsort posix_qsort
    139         #define bsearch posix_bsearch
    140 
    141         #define getenv posix_getenv
    142         #define putenv posix_putenv
    143         #define system posix_system
    144 
    145         #define realpath posix_realpath
    146        
    147         #define atof posix_atof
    148         #define strtof posix_strtof
    149         #define strtod posix_strtod
    150         #define strtold posix_strtold
    151        
    152         #define atoi posix_atoi
    153         #define atol posix_atol
    154         #define atoll posix_atoll
    155         #define strtol posix_strtol
    156         #define strtoll posix_strtoll
    157         #define strtoul posix_strtoul
    158         #define strtoull posix_strtoull
    159 
    160         #define malloc posix_malloc
    161         #define calloc posix_calloc
    162         #define realloc posix_realloc
    163         #define free posix_free
    164 
    165         #define mkstemp posix_mkstemp
    166 
    167         #define mktemp posix_mktemp
    168         #define getloadavg bsd_getloadavg
    169 #endif
    170127
    171128#endif  // POSIX_STDLIB_H_
  • uspace/lib/posix/include/posix/string.h

    rc84f1a4 rfdf97f6  
    3737#define POSIX_STRING_H_
    3838
     39#ifndef __POSIX_DEF__
     40#define __POSIX_DEF__(x) x
     41#endif
     42
    3943#include "sys/types.h"
    4044
     
    6569
    6670/* From mem.h */
    67 #define bzero(ptr, len)  memset((ptr), 0, (len))
     71// #define bzero(ptr, len)  memset((ptr), 0, (len))
    6872extern void *memset(void *, int, size_t);
    6973extern void *memcpy(void *, const void *, size_t);
     
    7276
    7377/* Copying and Concatenation */
    74 extern char *posix_strcpy(char *restrict dest, const char *restrict src);
    75 extern char *posix_strncpy(char *restrict dest, const char *restrict src, size_t n);
    76 extern char *posix_stpcpy(char *restrict dest, const char *restrict src);
    77 extern char *posix_stpncpy(char *restrict dest, const char *restrict src, size_t n);
    78 extern char *posix_strcat(char *restrict dest, const char *restrict src);
    79 extern char *posix_strncat(char *restrict dest, const char *restrict src, size_t n);
    80 extern void *posix_memccpy(void *restrict dest, const void *restrict src, int c, size_t n);
    81 extern char *posix_strdup(const char *s);
    82 extern char *posix_strndup(const char *s, size_t n);
     78extern char *__POSIX_DEF__(strcpy)(char *restrict dest, const char *restrict src);
     79extern char *__POSIX_DEF__(strncpy)(char *restrict dest, const char *restrict src, size_t n);
     80extern char *__POSIX_DEF__(stpcpy)(char *restrict dest, const char *restrict src);
     81extern char *__POSIX_DEF__(stpncpy)(char *restrict dest, const char *restrict src, size_t n);
     82extern char *__POSIX_DEF__(strcat)(char *restrict dest, const char *restrict src);
     83extern char *__POSIX_DEF__(strncat)(char *restrict dest, const char *restrict src, size_t n);
     84extern void *__POSIX_DEF__(memccpy)(void *restrict dest, const void *restrict src, int c, size_t n);
     85extern char *__POSIX_DEF__(strdup)(const char *s);
     86extern char *__POSIX_DEF__(strndup)(const char *s, size_t n);
    8387
    8488/* String/Array Comparison */
    85 extern int posix_memcmp(const void *mem1, const void *mem2, size_t n);
    86 extern int posix_strcmp(const char *s1, const char *s2);
    87 extern int posix_strncmp(const char *s1, const char *s2, size_t n);
     89extern int __POSIX_DEF__(memcmp)(const void *mem1, const void *mem2, size_t n);
     90extern int __POSIX_DEF__(strcmp)(const char *s1, const char *s2);
     91extern int __POSIX_DEF__(strncmp)(const char *s1, const char *s2, size_t n);
    8892
    8993/* Search Functions */
    90 extern void *posix_memchr(const void *mem, int c, size_t n);
    91 extern char *posix_strchr(const char *s, int c);
    92 extern char *posix_strrchr(const char *s, int c);
     94extern void *__POSIX_DEF__(memchr)(const void *mem, int c, size_t n);
     95extern char *__POSIX_DEF__(strchr)(const char *s, int c);
     96extern char *__POSIX_DEF__(strrchr)(const char *s, int c);
    9397extern char *gnu_strchrnul(const char *s, int c);
    94 extern char *posix_strpbrk(const char *s1, const char *s2);
    95 extern size_t posix_strcspn(const char *s1, const char *s2);
    96 extern size_t posix_strspn(const char *s1, const char *s2);
    97 extern char *posix_strstr(const char *haystack, const char *needle);
     98extern char *__POSIX_DEF__(strpbrk)(const char *s1, const char *s2);
     99extern size_t __POSIX_DEF__(strcspn)(const char *s1, const char *s2);
     100extern size_t __POSIX_DEF__(strspn)(const char *s1, const char *s2);
     101extern char *__POSIX_DEF__(strstr)(const char *haystack, const char *needle);
    98102
    99103/* Collation Functions */
    100 extern int posix_strcoll(const char *s1, const char *s2);
    101 extern size_t posix_strxfrm(char *restrict s1, const char *restrict s2, size_t n);
     104extern int __POSIX_DEF__(strcoll)(const char *s1, const char *s2);
     105extern size_t __POSIX_DEF__(strxfrm)(char *restrict s1, const char *restrict s2, size_t n);
    102106
    103107/* Error Messages */
    104 extern char *posix_strerror(int errnum);
    105 extern int posix_strerror_r(int errnum, char *buf, size_t bufsz);
     108extern char *__POSIX_DEF__(strerror)(int errnum);
     109extern int __POSIX_DEF__(strerror_r)(int errnum, char *buf, size_t bufsz);
    106110
    107111/* String Length */
    108 extern size_t posix_strlen(const char *s);
    109 extern size_t posix_strnlen(const char *s, size_t n);
     112extern size_t __POSIX_DEF__(strlen)(const char *s);
     113extern size_t __POSIX_DEF__(strnlen)(const char *s, size_t n);
    110114
    111115/* Signal Messages */
    112 extern char *posix_strsignal(int signum);
     116extern char *__POSIX_DEF__(strsignal)(int signum);
    113117
    114118/* Legacy Declarations */
    115119#ifndef POSIX_STRINGS_H_
    116 extern int posix_ffs(int i);
    117 extern int posix_strcasecmp(const char *s1, const char *s2);
    118 extern int posix_strncasecmp(const char *s1, const char *s2, size_t n);
     120extern int __POSIX_DEF__(ffs)(int i);
     121extern int __POSIX_DEF__(strcasecmp)(const char *s1, const char *s2);
     122extern int __POSIX_DEF__(strncasecmp)(const char *s1, const char *s2, size_t n);
    119123#endif
    120124
    121 #ifndef LIBPOSIX_INTERNAL
    122         #define strcpy posix_strcpy
    123         #define strncpy posix_strncpy
    124         #define stpcpy posix_stpcpy
    125         #define stpncpy posix_stpncpy
    126         #define strcat posix_strcat
    127         #define strncat posix_strncat
    128         #define memccpy posix_memccpy
    129         #define strdup posix_strdup
    130         #define strndup posix_strndup
    131 
    132         #define memcmp posix_memcmp
    133         #define strcmp posix_strcmp
    134         #define strncmp posix_strncmp
    135 
    136         #define memchr posix_memchr
    137         #define strchr posix_strchr
    138         #define strrchr posix_strrchr
    139         #define strchrnul gnu_strchrnul
    140         #define strpbrk posix_strpbrk
    141         #define strcspn posix_strcspn
    142         #define strspn posix_strspn
    143         #define strstr posix_strstr
    144 
    145         #define strcoll posix_strcoll
    146         #define strxfrm posix_strxfrm
    147 
    148         #define strerror posix_strerror
    149         #define strerror_r posix_strerror_r
    150 
    151         #define strlen posix_strlen
    152         #define strnlen posix_strnlen
    153 
    154         #define strsignal posix_strsignal
    155 
    156         #define ffs posix_ffs
    157         #define strcasecmp posix_strcasecmp
    158         #define strncasecmp posix_strncasecmp
    159 #endif
    160125
    161126#endif  // POSIX_STRING_H_
  • uspace/lib/posix/include/posix/strings.h

    rc84f1a4 rfdf97f6  
    3737#define POSIX_STRINGS_H_
    3838
     39#ifndef __POSIX_DEF__
     40#define __POSIX_DEF__(x) x
     41#endif
     42
    3943/* Search Functions */
    4044#ifndef POSIX_STRING_H_
    41 extern int posix_ffs(int i);
     45extern int __POSIX_DEF__(ffs)(int i);
    4246#endif
    4347
    4448/* String/Array Comparison */
    4549#ifndef POSIX_STRING_H_
    46 extern int posix_strcasecmp(const char *s1, const char *s2);
    47 extern int posix_strncasecmp(const char *s1, const char *s2, size_t n);
     50extern int __POSIX_DEF__(strcasecmp)(const char *s1, const char *s2);
     51extern int __POSIX_DEF__(strncasecmp)(const char *s1, const char *s2, size_t n);
    4852#endif
    4953
     
    5559
    5660/* Legacy Functions */
    57 extern 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);
    59 extern void posix_bzero(void *mem, size_t n);
    60 extern char *posix_index(const char *s, int c);
    61 extern char *posix_rindex(const char *s, int c);
     61extern int __POSIX_DEF__(bcmp)(const void *mem1, const void *mem2, size_t n);
     62extern void __POSIX_DEF__(bcopy)(const void *src, void *dest, size_t n);
     63extern void __POSIX_DEF__(bzero)(void *mem, size_t n);
     64extern char *__POSIX_DEF__(index)(const char *s, int c);
     65extern char *__POSIX_DEF__(rindex)(const char *s, int c);
    6266
    63 #ifndef LIBPOSIX_INTERNAL
    64         #define ffs posix_ffs
    65 
    66         #define strcasecmp posix_strcasecmp
    67         #define strncasecmp posix_strncasecmp
    68 
    69         #define bcmp posix_bcmp
    70         #define bcopy posix_bcopy
    71         #undef bzero
    72         #define bzero posix_bzero
    73         #define index posix_index
    74         #define rindex posix_rindex
    75 #endif
    7667
    7768#endif  // POSIX_STRINGS_H_
  • uspace/lib/posix/include/posix/sys/mman.h

    rc84f1a4 rfdf97f6  
    3636#define POSIX_SYS_MMAN_H_
    3737
     38#ifndef __POSIX_DEF__
     39#define __POSIX_DEF__(x) x
     40#endif
     41
    3842#include "sys/types.h"
    3943#include <abi/mm/as.h>
     
    5660
    5761extern void *mmap(void *start, size_t length, int prot, int flags, int fd,
    58     posix_off_t offset);
     62    __POSIX_DEF__(off_t) offset);
    5963extern int munmap(void *start, size_t length);
     64
    6065
    6166#endif /* POSIX_SYS_MMAN_H_ */
  • uspace/lib/posix/include/posix/sys/stat.h

    rc84f1a4 rfdf97f6  
    3939#include "types.h"
    4040#include "../time.h"
     41
     42#ifndef __POSIX_DEF__
     43#define __POSIX_DEF__(x) x
     44#endif
    4145
    4246/* values are the same as on Linux */
     
    108112#define S_ISSOCK(m) ((m & S_IFSOCK) != 0) /* socket? (Not in POSIX.1-1996.) */
    109113
    110 struct posix_stat {
    111         posix_dev_t     st_dev;     /* ID of device containing file */
    112         posix_ino_t     st_ino;     /* inode number */
     114struct __POSIX_DEF__(stat) {
     115        __POSIX_DEF__(dev_t)     st_dev;     /* ID of device containing file */
     116        __POSIX_DEF__(ino_t)     st_ino;     /* inode number */
    113117        mode_t          st_mode;    /* protection */
    114         posix_nlink_t   st_nlink;   /* number of hard links */
    115         posix_uid_t     st_uid;     /* user ID of owner */
    116         posix_gid_t     st_gid;     /* group ID of owner */
    117         posix_dev_t     st_rdev;    /* device ID (if special file) */
    118         posix_off_t     st_size;    /* total size, in bytes */
    119         posix_blksize_t st_blksize; /* blocksize for file system I/O */
    120         posix_blkcnt_t  st_blocks;  /* number of 512B blocks allocated */
     118        __POSIX_DEF__(nlink_t)   st_nlink;   /* number of hard links */
     119        __POSIX_DEF__(uid_t)     st_uid;     /* user ID of owner */
     120        __POSIX_DEF__(gid_t)     st_gid;     /* group ID of owner */
     121        __POSIX_DEF__(dev_t)     st_rdev;    /* device ID (if special file) */
     122        __POSIX_DEF__(off_t)     st_size;    /* total size, in bytes */
     123        __POSIX_DEF__(blksize_t) st_blksize; /* blocksize for file system I/O */
     124        __POSIX_DEF__(blkcnt_t)  st_blocks;  /* number of 512B blocks allocated */
    121125        time_t          st_atime;   /* time of last access */
    122126        time_t          st_mtime;   /* time of last modification */
     
    124128};
    125129
    126 extern int posix_fstat(int fd, struct posix_stat *st);
    127 extern int posix_lstat(const char *restrict path, struct posix_stat *restrict st);
    128 extern int posix_stat(const char *restrict path, struct posix_stat *restrict st);
    129 extern int posix_chmod(const char *path, mode_t mode);
    130 extern mode_t posix_umask(mode_t mask);
     130extern int __POSIX_DEF__(fstat)(int fd, struct __POSIX_DEF__(stat) *st);
     131extern int __POSIX_DEF__(lstat)(const char *restrict path, struct __POSIX_DEF__(stat) *restrict st);
     132extern int __POSIX_DEF__(stat)(const char *restrict path, struct __POSIX_DEF__(stat) *restrict st);
     133extern int __POSIX_DEF__(chmod)(const char *path, mode_t mode);
     134extern mode_t __POSIX_DEF__(umask)(mode_t mask);
    131135extern int mkdir(const char *, mode_t);
    132136
    133 #ifndef LIBPOSIX_INTERNAL
    134         #define fstat posix_fstat
    135         #define lstat posix_lstat
    136         #define stat posix_stat
    137         #define chmod posix_chmod
    138         #define umask posix_umask
    139 #endif
    140137
    141138#endif /* POSIX_SYS_STAT_H */
  • uspace/lib/posix/include/posix/sys/types.h

    rc84f1a4 rfdf97f6  
    3737#define POSIX_SYS_TYPES_H_
    3838
     39#ifndef __POSIX_DEF__
     40#define __POSIX_DEF__(x) x
     41#endif
     42
    3943#include "libc/sys/types.h"
    4044#include "libc/sys/time.h"
    4145
    42 typedef unsigned int posix_ino_t;
    43 typedef unsigned int posix_nlink_t;
    44 typedef unsigned int posix_uid_t;
    45 typedef unsigned int posix_gid_t;
    46 typedef off64_t posix_off_t;
    47 typedef long posix_blksize_t;
    48 typedef long posix_blkcnt_t;
    49 typedef int64_t posix_pid_t;
    50 typedef sysarg_t posix_dev_t;
     46typedef unsigned int __POSIX_DEF__(ino_t);
     47typedef unsigned int __POSIX_DEF__(nlink_t);
     48typedef unsigned int __POSIX_DEF__(uid_t);
     49typedef unsigned int __POSIX_DEF__(gid_t);
     50typedef off64_t __POSIX_DEF__(off_t);
     51typedef long __POSIX_DEF__(blksize_t);
     52typedef long __POSIX_DEF__(blkcnt_t);
     53typedef int64_t __POSIX_DEF__(pid_t);
     54typedef sysarg_t __POSIX_DEF__(dev_t);
    5155
    5256/* PThread Types */
    53 typedef struct posix_thread_attr posix_thread_attr_t;
     57typedef struct __POSIX_DEF__(thread_attr) __POSIX_DEF__(thread_attr_t);
    5458
    5559/* Clock Types */
    56 typedef long posix_clock_t;
    57 typedef int posix_clockid_t;
     60typedef long __POSIX_DEF__(clock_t);
     61typedef int __POSIX_DEF__(clockid_t);
    5862
    59 #ifndef LIBPOSIX_INTERNAL
    60         #define ino_t posix_ino_t
    61         #define nlink_t posix_nlink_t
    62         #define uid_t posix_uid_t
    63         #define gid_t posix_gid_t
    64         #define off_t posix_off_t
    65         #define blksize_t posix_blksize_t
    66         #define blkcnt_t posix_blkcnt_t
    67         #define pid_t posix_pid_t
    68         #define dev_t posix_dev_t
    69        
    70         #define pthread_attr_t posix_thread_attr_t
    71        
    72         #define clock_t posix_clock_t
    73         #define clockid_t posix_clockid_t
    74 #endif
    7563
    7664#endif /* POSIX_SYS_TYPES_H_ */
  • uspace/lib/posix/include/posix/sys/wait.h

    rc84f1a4 rfdf97f6  
    3636#define POSIX_SYS_WAIT_H_
    3737
     38#ifndef __POSIX_DEF__
     39#define __POSIX_DEF__(x) x
     40#endif
     41
    3842#include "types.h"
    3943
     
    5256extern int __posix_wtermsig(int status);
    5357
    54 extern posix_pid_t posix_wait(int *stat_ptr);
    55 extern posix_pid_t posix_waitpid(posix_pid_t pid, int *stat_ptr, int options);
     58extern __POSIX_DEF__(pid_t) __POSIX_DEF__(wait)(int *stat_ptr);
     59extern __POSIX_DEF__(pid_t) __POSIX_DEF__(waitpid)(__POSIX_DEF__(pid_t) pid, int *stat_ptr, int options);
    5660
    57 #ifndef LIBPOSIX_INTERNAL
    58         #define wait posix_wait
    59         #define waitpid posix_waitpid
    60 #endif
    6161
    6262#endif /* POSIX_SYS_WAIT_H_ */
  • uspace/lib/posix/include/posix/time.h

    rc84f1a4 rfdf97f6  
    3737#define POSIX_TIME_H_
    3838
     39#ifndef __POSIX_DEF__
     40#define __POSIX_DEF__(x) x
     41#endif
     42
    3943#include "sys/types.h"
    4044
     
    4953#ifndef __locale_t_defined
    5054        #define __locale_t_defined
    51         typedef struct __posix_locale *posix_locale_t;
     55        typedef struct __posix_locale *__POSIX_DEF__(locale_t);
    5256        #ifndef LIBPOSIX_INTERNAL
    53                 #define locale_t posix_locale_t
     57                #define locale_t __POSIX_DEF__(locale_t)
    5458        #endif
    5559#endif
    5660
    5761#ifndef POSIX_SIGNAL_H_
    58         struct posix_sigevent;
     62        struct __POSIX_DEF__(sigevent);
    5963        #ifndef LIBPOSIX_INTERNAL
    60                 #define sigevent posix_sigevent
     64                #define sigevent __POSIX_DEF__(sigevent)
    6165        #endif
    6266#endif
    6367
    6468#undef CLOCK_REALTIME
    65 #define CLOCK_REALTIME ((posix_clockid_t) 0)
     69#define CLOCK_REALTIME ((__POSIX_DEF__(clockid_t)) 0)
    6670
    67 struct posix_timespec {
     71struct __POSIX_DEF__(timespec) {
    6872        time_t tv_sec; /* Seconds. */
    6973        long tv_nsec; /* Nanoseconds. */
    7074};
    7175
    72 struct posix_itimerspec {
    73         struct posix_timespec it_interval; /* Timer period. */
    74         struct posix_timespec it_value; /* Timer expiration. */
     76struct __POSIX_DEF__(itimerspec) {
     77        struct __POSIX_DEF__(timespec) it_interval; /* Timer period. */
     78        struct __POSIX_DEF__(timespec) it_value; /* Timer expiration. */
    7579};
    7680
    77 typedef struct __posix_timer *posix_timer_t;
     81typedef struct __posix_timer *__POSIX_DEF__(timer_t);
    7882
    7983/* Timezones */
    80 extern int posix_daylight;
    81 extern long posix_timezone;
    82 extern char *posix_tzname[2];
    83 extern void posix_tzset(void);
     84extern int __POSIX_DEF__(daylight);
     85extern long __POSIX_DEF__(timezone);
     86extern char *__POSIX_DEF__(tzname)[2];
     87extern void __POSIX_DEF__(tzset)(void);
    8488
    8589/* Broken-down Time */
    86 extern struct tm *posix_gmtime_r(const time_t *restrict timer,
     90extern struct tm *__POSIX_DEF__(gmtime_r)(const time_t *restrict timer,
    8791    struct tm *restrict result);
    88 extern struct tm *posix_gmtime(const time_t *restrict timep);
    89 extern struct tm *posix_localtime_r(const time_t *restrict timer,
     92extern struct tm *__POSIX_DEF__(gmtime)(const time_t *restrict timep);
     93extern struct tm *__POSIX_DEF__(localtime_r)(const time_t *restrict timer,
    9094    struct tm *restrict result);
    91 extern struct tm *posix_localtime(const time_t *restrict timep);
     95extern struct tm *__POSIX_DEF__(localtime)(const time_t *restrict timep);
    9296
    9397/* Formatting Calendar Time */
    94 extern char *posix_asctime_r(const struct tm *restrict timeptr,
     98extern char *__POSIX_DEF__(asctime_r)(const struct tm *restrict timeptr,
    9599    char *restrict buf);
    96 extern char *posix_asctime(const struct tm *restrict timeptr);
    97 extern char *posix_ctime_r(const time_t *timer, char *buf);
    98 extern char *posix_ctime(const time_t *timer);
     100extern char *__POSIX_DEF__(asctime)(const struct tm *restrict timeptr);
     101extern char *__POSIX_DEF__(ctime_r)(const time_t *timer, char *buf);
     102extern char *__POSIX_DEF__(ctime)(const time_t *timer);
    99103
    100104/* Clocks */
    101 extern int posix_clock_getres(posix_clockid_t clock_id,
    102     struct posix_timespec *res);
    103 extern int posix_clock_gettime(posix_clockid_t clock_id,
    104     struct posix_timespec *tp);
    105 extern int posix_clock_settime(posix_clockid_t clock_id,
    106     const struct posix_timespec *tp);
    107 extern int posix_clock_nanosleep(posix_clockid_t clock_id, int flags,
    108     const struct posix_timespec *rqtp, struct posix_timespec *rmtp);
     105extern int __POSIX_DEF__(clock_getres)(__POSIX_DEF__(clockid_t) clock_id,
     106    struct __POSIX_DEF__(timespec) *res);
     107extern int __POSIX_DEF__(clock_gettime)(__POSIX_DEF__(clockid_t) clock_id,
     108    struct __POSIX_DEF__(timespec) *tp);
     109extern int __POSIX_DEF__(clock_settime)(__POSIX_DEF__(clockid_t) clock_id,
     110    const struct __POSIX_DEF__(timespec) *tp);
     111extern int __POSIX_DEF__(clock_nanosleep)(__POSIX_DEF__(clockid_t) clock_id, int flags,
     112    const struct __POSIX_DEF__(timespec) *rqtp, struct __POSIX_DEF__(timespec) *rmtp);
    109113
    110114/* CPU Time */
    111 extern posix_clock_t posix_clock(void);
     115extern __POSIX_DEF__(clock_t) __POSIX_DEF__(clock)(void);
    112116
    113 #ifndef LIBPOSIX_INTERNAL
    114         #define timespec    posix_timespec
    115         #define itimerspec  posix_itimerspec
    116         #define timer_t     posix_timer_t
    117 
    118         #define daylight    posix_daylight
    119         #define timezone    posix_timezone
    120         #define tzname      posix_tzname
    121         #define tzset       posix_tzset
    122 
    123         #define gmtime_r    posix_gmtime_r
    124         #define gmtime      posix_gmtime
    125         #define localtime_r posix_localtime_r
    126         #define localtime   posix_localtime
    127 
    128         #define asctime_r   posix_asctime_r
    129         #define asctime     posix_asctime
    130         #define ctime_r     posix_ctime_r
    131         #define ctime       posix_ctime
    132 
    133         #define clock_getres posix_clock_getres
    134         #define clock_gettime posix_clock_gettime
    135         #define clock_settime posix_clock_settime
    136         #define clock_nanosleep posix_clock_nanosleep
    137 
    138         #define clock posix_clock
    139 #endif
    140117
    141118#endif  // POSIX_TIME_H_
  • uspace/lib/posix/include/posix/unistd.h

    rc84f1a4 rfdf97f6  
    3737#define POSIX_UNISTD_H_
    3838
     39#ifndef __POSIX_DEF__
     40#define __POSIX_DEF__(x) x
     41#endif
     42
    3943#include "sys/types.h"
    4044#include "stddef.h"
     
    4347#define _exit exit
    4448
    45 extern char *posix_optarg;
     49extern char *__POSIX_DEF__(optarg);
    4650extern int optind, opterr, optopt;
    47 extern int posix_getopt(int, char * const [], const char *);
     51extern int __POSIX_DEF__(getopt)(int, char * const [], const char *);
    4852
    4953/* Environment */
    50 extern char **posix_environ;
     54extern char **__POSIX_DEF__(environ);
    5155
    5256/* Login Information */
    53 extern char *posix_getlogin(void);
    54 extern int posix_getlogin_r(char *name, size_t namesize);
     57extern char *__POSIX_DEF__(getlogin)(void);
     58extern int __POSIX_DEF__(getlogin_r)(char *name, size_t namesize);
    5559
    5660/* Identifying Terminals */
    57 extern int posix_isatty(int fd);
     61extern int __POSIX_DEF__(isatty)(int fd);
    5862
    5963/* Working Directory */
    60 extern char *posix_getcwd(char *buf, size_t size);
    61 extern int posix_chdir(const char *path);
     64extern char *__POSIX_DEF__(getcwd)(char *buf, size_t size);
     65extern int __POSIX_DEF__(chdir)(const char *path);
    6266
    6367/* Query Memory Parameters */
    64 extern int posix_getpagesize(void);
     68extern int __POSIX_DEF__(getpagesize)(void);
    6569
    6670/* Process Identification */
    67 extern posix_pid_t posix_getpid(void);
    68 extern posix_uid_t posix_getuid(void);
    69 extern posix_gid_t posix_getgid(void);
     71extern __POSIX_DEF__(pid_t) __POSIX_DEF__(getpid)(void);
     72extern __POSIX_DEF__(uid_t) __POSIX_DEF__(getuid)(void);
     73extern __POSIX_DEF__(gid_t) __POSIX_DEF__(getgid)(void);
    7074
    7175/* File Manipulation */
    72 extern int posix_close(int fildes);
    73 extern ssize_t posix_read(int fildes, void *buf, size_t nbyte);
    74 extern ssize_t posix_write(int fildes, const void *buf, size_t nbyte);
    75 extern int posix_fsync(int fildes);
    76 extern int posix_ftruncate(int fildes, posix_off_t length);
    77 extern int posix_rmdir(const char *path);
    78 extern int posix_unlink(const char *path);
    79 extern int posix_dup(int fildes);
    80 extern int posix_dup2(int fildes, int fildes2);
     76extern int __POSIX_DEF__(close)(int fildes);
     77extern ssize_t __POSIX_DEF__(read)(int fildes, void *buf, size_t nbyte);
     78extern ssize_t __POSIX_DEF__(write)(int fildes, const void *buf, size_t nbyte);
     79extern int __POSIX_DEF__(fsync)(int fildes);
     80extern int __POSIX_DEF__(ftruncate)(int fildes, __POSIX_DEF__(off_t) length);
     81extern int __POSIX_DEF__(rmdir)(const char *path);
     82extern int __POSIX_DEF__(unlink)(const char *path);
     83extern int __POSIX_DEF__(dup)(int fildes);
     84extern int __POSIX_DEF__(dup2)(int fildes, int fildes2);
    8185
    8286/* Standard Streams */
     
    97101#define W_OK 2 /* Test for write permission. */
    98102#define R_OK 4 /* Test for read permission. */
    99 extern int posix_access(const char *path, int amode);
     103extern int __POSIX_DEF__(access)(const char *path, int amode);
    100104
    101105/* System Parameters */
     
    106110        _SC_CLK_TCK
    107111};
    108 extern long posix_sysconf(int name);
     112extern long __POSIX_DEF__(sysconf)(int name);
    109113
    110114/* Path Configuration Parameters */
     
    130134        _PC_VDISABLE
    131135};
    132 extern long posix_pathconf(const char *path, int name);
     136extern long __POSIX_DEF__(pathconf)(const char *path, int name);
    133137
    134138/* Creating a Process */
    135 extern posix_pid_t posix_fork(void);
     139extern __POSIX_DEF__(pid_t) __POSIX_DEF__(fork)(void);
    136140
    137141/* Executing a File */
    138 extern int posix_execv(const char *path, char *const argv[]);
    139 extern int posix_execvp(const char *file, char *const argv[]);
     142extern int __POSIX_DEF__(execv)(const char *path, char *const argv[]);
     143extern int __POSIX_DEF__(execvp)(const char *file, char *const argv[]);
    140144
    141145/* Creating a Pipe */
    142 extern int posix_pipe(int fildes[2]);
     146extern int __POSIX_DEF__(pipe)(int fildes[2]);
    143147
    144 #ifndef LIBPOSIX_INTERNAL
    145         #define getopt posix_getopt
    146         #define optarg posix_optarg
    147 
    148         #define environ posix_environ
    149 
    150         #define getlogin posix_getlogin
    151         #define getlogin_r posix_getlogin_r
    152 
    153         #define getcwd posix_getcwd
    154         #define chdir posix_chdir
    155 
    156         #define isatty posix_isatty
    157 
    158         #undef getpagesize
    159         #define getpagesize posix_getpagesize
    160 
    161         #define getpid posix_getpid
    162         #define getuid posix_getuid
    163         #define getgid posix_getgid
    164 
    165         #define close posix_close
    166         #define read posix_read
    167         #define write posix_write
    168         #define fsync posix_fsync
    169         #define ftruncate posix_ftruncate
    170         #define rmdir posix_rmdir
    171         #define unlink posix_unlink
    172         #define dup posix_dup
    173         #define dup2 posix_dup2
    174 
    175         #define access posix_access
    176 
    177         #define sysconf posix_sysconf
    178 
    179         #define pathconf posix_pathconf
    180 
    181         #define fork posix_fork
    182 
    183         #define execv posix_execv
    184         #define execvp posix_execvp
    185 
    186         #define pipe posix_pipe
    187 #endif
    188148
    189149#endif /* POSIX_UNISTD_H_ */
  • uspace/lib/posix/source/ctype.c

    rc84f1a4 rfdf97f6  
    3535
    3636#define LIBPOSIX_INTERNAL
     37#define __POSIX_DEF__(x) posix_##x
    3738
    3839#include "posix/ctype.h"
  • uspace/lib/posix/source/errno.c

    rc84f1a4 rfdf97f6  
    3232/** @file System error numbers.
    3333 */
     34#define LIBPOSIX_INTERNAL
     35#define __POSIX_DEF__(x) posix_##x
    3436
    3537#include "posix/errno.h"
     
    4345{
    4446        if (*__errno() != 0) {
    45                 _posix_errno = abs(*__errno());
     47                _posix_errno = posix_abs(*__errno());
    4648                *__errno() = 0;
    4749        }
  • uspace/lib/posix/source/fcntl.c

    rc84f1a4 rfdf97f6  
    3434
    3535#define LIBPOSIX_INTERNAL
     36#define __POSIX_DEF__(x) posix_##x
    3637
    3738#include "internal/common.h"
  • uspace/lib/posix/source/fnmatch.c

    rc84f1a4 rfdf97f6  
    4343
    4444#define LIBPOSIX_INTERNAL
     45#define __POSIX_DEF__(x) posix_##x
    4546
    4647#include "libc/stdbool.h"
  • uspace/lib/posix/source/getopt.c

    rc84f1a4 rfdf97f6  
    3333 */
    3434#define LIBPOSIX_INTERNAL
     35#define __POSIX_DEF__(x) posix_##x
    3536
    3637#include "internal/common.h"
  • uspace/lib/posix/source/locale.c

    rc84f1a4 rfdf97f6  
    3434
    3535#define LIBPOSIX_INTERNAL
     36#define __POSIX_DEF__(x) posix_##x
    3637
    3738#include "internal/common.h"
  • uspace/lib/posix/source/math.c

    rc84f1a4 rfdf97f6  
    3434
    3535#define LIBPOSIX_INTERNAL
     36#define __POSIX_DEF__(x) posix_##x
    3637
    3738#include "internal/common.h"
  • uspace/lib/posix/source/pwd.c

    rc84f1a4 rfdf97f6  
    3434
    3535#define LIBPOSIX_INTERNAL
     36#define __POSIX_DEF__(x) posix_##x
    3637
    3738#include "libc/stdbool.h"
  • uspace/lib/posix/source/signal.c

    rc84f1a4 rfdf97f6  
    3434
    3535#define LIBPOSIX_INTERNAL
     36#define __POSIX_DEF__(x) posix_##x
    3637
    3738#include "posix/signal.h"
  • uspace/lib/posix/source/stdio.c

    rc84f1a4 rfdf97f6  
    3535
    3636#define LIBPOSIX_INTERNAL
     37#define __POSIX_DEF__(x) posix_##x
    3738
    3839#include "internal/common.h"
  • uspace/lib/posix/source/stdio/scanf.c

    rc84f1a4 rfdf97f6  
    3434
    3535#define LIBPOSIX_INTERNAL
     36#define __POSIX_DEF__(x) posix_##x
    3637
    3738#include "posix/assert.h"
  • uspace/lib/posix/source/stdlib.c

    rc84f1a4 rfdf97f6  
    3535
    3636#define LIBPOSIX_INTERNAL
     37#define __POSIX_DEF__(x) posix_##x
    3738
    3839#include "internal/common.h"
  • uspace/lib/posix/source/stdlib/strtol.c

    rc84f1a4 rfdf97f6  
    3434
    3535#define LIBPOSIX_INTERNAL
     36#define __POSIX_DEF__(x) posix_##x
    3637
    3738#include "../internal/common.h"
  • uspace/lib/posix/source/stdlib/strtold.c

    rc84f1a4 rfdf97f6  
    3434
    3535#define LIBPOSIX_INTERNAL
     36#define __POSIX_DEF__(x) posix_##x
    3637
    3738#include "../internal/common.h"
  • uspace/lib/posix/source/string.c

    rc84f1a4 rfdf97f6  
    3535
    3636#define LIBPOSIX_INTERNAL
     37#define __POSIX_DEF__(x) posix_##x
    3738
    3839#include "internal/common.h"
  • uspace/lib/posix/source/strings.c

    rc84f1a4 rfdf97f6  
    3535
    3636#define LIBPOSIX_INTERNAL
     37#define __POSIX_DEF__(x) posix_##x
    3738
    3839#include "internal/common.h"
  • uspace/lib/posix/source/sys/stat.c

    rc84f1a4 rfdf97f6  
    3535
    3636#define LIBPOSIX_INTERNAL
     37#define __POSIX_DEF__(x) posix_##x
    3738
    3839#include "../internal/common.h"
  • uspace/lib/posix/source/sys/wait.c

    rc84f1a4 rfdf97f6  
    3535
    3636#define LIBPOSIX_INTERNAL
     37#define __POSIX_DEF__(x) posix_##x
    3738
    3839#include "../internal/common.h"
  • uspace/lib/posix/source/time.c

    rc84f1a4 rfdf97f6  
    3535
    3636#define LIBPOSIX_INTERNAL
     37#define __POSIX_DEF__(x) posix_##x
    3738
    3839#include "internal/common.h"
  • uspace/lib/posix/source/unistd.c

    rc84f1a4 rfdf97f6  
    3535
    3636#define LIBPOSIX_INTERNAL
     37#define __POSIX_DEF__(x) posix_##x
    3738
    3839#include "internal/common.h"
Note: See TracChangeset for help on using the changeset viewer.