Changeset c8bb1633 in mainline


Ignore:
Timestamp:
2013-07-10T08:58:49Z (11 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
3908355, 4c53333
Parents:
30c1b75 (diff), 98abd40 (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:

Extending POSIX library

Merge from lp:~vojtech-horky/helenos/gcc-port.

This is work-in-progress merge from branch aimed at bringing GCC to run
inside HelenOS.

The most notable change is dealing with the name clashes in libposix and
libc. For ported applications, the libposix headers looks as normal
POSIX headers and there is no need to do preprocessor-based renaming inside
the ported application. The renaming is done inside object files instead.
See revision 1745 in lp:~vojtech-horky/helenos/gcc-port [1] for more
detailed explanation.
The solution is definitely not perfect but shall deal with the naming
conflicts in much safer manner than using the redefines.

There were some other changes as well, mostly small ones.

  • Add some functions, some as ToDo ones (i.e. empty implementation).
  • Add more POSIX headers, split some existing.

[1] ​http://bazaar.launchpad.net/~vojtech-horky/helenos/gcc-port/revision/1745

Location:
uspace
Files:
7 added
51 edited

Legend:

Unmodified
Added
Removed

  • uspace/Makefile.common

    r30c1b75 rc8bb1633  
    222222endif
    223223
    224 ## Setup platform configuration
    225 #
    226 
    227 -include $(LIBC_PREFIX)/arch/$(UARCH)/Makefile.common
    228 
    229 ## Compilation options
    230 #
    231 
    232 JOBFILE = $(LIBC_PREFIX)/../../../tools/jobfile.py
    233 
     224# Prepare for POSIX before including platform specific stuff
    234225ifeq ($(POSIX_COMPAT),y)
    235226        CFLAGS = -I$(LIBPOSIX_PREFIX)/include/posix  -I$(LIBPOSIX_PREFIX)/include/
    236         LIBS += $(LIBPOSIX_PREFIX)/libposix.a
    237 endif
     227        BASE_LIBS = $(LIBPOSIX_PREFIX)/libposixaslibc.a $(LIBPOSIX_PREFIX)/libc4posix.a $(LIBSOFTINT_PREFIX)/libsoftint.a
     228endif
     229
     230## Setup platform configuration
     231#
     232
     233-include $(LIBC_PREFIX)/arch/$(UARCH)/Makefile.common
     234
     235## Compilation options
     236#
     237
     238JOBFILE = $(LIBC_PREFIX)/../../../tools/jobfile.py
    238239
    239240ifeq ($(COMPILER),gcc_cross)

  • uspace/app/bdsh/cmds/builtins/batch/batch.c

    r30c1b75 rc8bb1633  
    2929#include <stdio.h>
    3030#include <stdlib.h>
     31#include <stdbool.h>
     32#include <errno.h>
    3133#include "config.h"
    3234#include "util.h"
    … …  
    4446        if (level == HELP_SHORT) {
    4547                printf(
    46                 "\n  batch [filename]\n"
     48                "\n  batch [filename] [-c]\n"
    4749                "  Issues commands stored in the file.\n"
    4850                "  Each command must correspond to the single line in the file.\n\n");
    … …  
    5456                "  separate groups of commands. There is no support for comments,\n"
    5557                "  variables, recursion or other programming constructs - the `batch'\n"
    56                 "  command is indeed very trivial.\n\n");
     58                "  command is indeed very trivial.\n"
     59                "  If the filename is followed by -c, execution continues even if some\n"
     60                "  of the commands failed.\n\n");
    5761        }
    5862
    … …  
    6569{
    6670        unsigned int argc;
     71        bool continue_despite_errors = false;
    6772
    6873        /* Count the arguments */
    … …  
    7277                printf("%s - no input file provided.\n", cmdname);
    7378                return CMD_FAILURE;
     79        }
     80
     81        if (argc > 2) {
     82                if (str_cmp(argv[2], "-c") == 0)
     83                        continue_despite_errors = true;
    7484        }
    7585
    … …  
    99109                                        rc = process_input(&fusr);
    100110                                        /* fusr->line was freed by process_input() */
     111                                        if ((rc != EOK) && continue_despite_errors) {
     112                                                /* Mute the error. */
     113                                                rc = EOK;
     114                                        }
    101115                                }
    102116                                if (rc == 0 && c != EOF) {

  • uspace/app/binutils/intrusive.sh

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    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/c/Makefile

    r30c1b75 rc8bb1633  
    6161        generic/bd.c \
    6262        generic/bd_srv.c \
     63        generic/bitops.c \
    6364        generic/cap.c \
    6465        generic/cfg.c \

  • uspace/lib/c/generic/io/io.c

    r30c1b75 rc8bb1633  
    192192}
    193193
     194/** Set stream buffer.
     195 *
     196 * When @p buf is NULL, the stream is set as unbuffered, otherwise
     197 * full buffering is enabled.
     198 */
     199void setbuf(FILE *stream, void *buf)
     200{
     201        if (buf == NULL) {
     202                setvbuf(stream, NULL, _IONBF, BUFSIZ);
     203        } else {
     204                setvbuf(stream, buf, _IOFBF, BUFSIZ);
     205        }
     206}
     207
    194208static void _setvbuf(FILE *stream)
    195209{

  • uspace/lib/c/include/bitops.h

    r30c1b75 rc8bb1633  
    107107}
    108108
     109extern int __popcountsi2(int);
     110
    109111#endif
    110112

  • uspace/lib/c/include/stdio.h

    r30c1b75 rc8bb1633  
    143143
    144144extern void setvbuf(FILE *, void *, int, size_t);
     145extern void setbuf(FILE *, void *);
    145146
    146147/* Misc file functions */

  • uspace/lib/posix/Makefile

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    3535#ifndef POSIX_FCNTL_H_
    3636#define POSIX_FCNTL_H_
     37
     38#ifndef __POSIX_DEF__
     39#define __POSIX_DEF__(x) x
     40#endif
    3741
    3842#include "sys/types.h"
    … …  
    7680#define FD_CLOEXEC         1 /* Close on exec. */
    7781
    78 extern int posix_open(const char *pathname, int flags, ...);
    79 extern int posix_fcntl(int fd, int cmd, ...);
     82extern int __POSIX_DEF__(open)(const char *pathname, int flags, ...);
     83extern int __POSIX_DEF__(fcntl)(int fd, int cmd, ...);
    8084
    81 #ifndef LIBPOSIX_INTERNAL
    82         #define fcntl posix_fcntl
    83         #define open posix_open
    84 #endif
    8585
    8686#endif /* POSIX_FCNTL_H_ */

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

    r30c1b75 rc8bb1633  
    6161        #undef FLT_RADIX
    6262        #define FLT_RADIX __FLT_RADIX__
     63#else
     64/* For something else than GCC, following definitions are provided.
     65 * They are intentionally guarded by the given macro to ensure that anyone
     66 * who wants them states this explicitly.
     67 *
     68 * The values are the ones GCC prints when compiled on i686 Linux.
     69 *
     70 * WARNING: the values are not accurate (especially the long double ones)!
     71 *
     72 */
     73#ifdef FLOAT_H_YES_I_REALLY_WANT_LIMITS
     74/* float limits */
     75#define FLT_MIN 1.1754943508222875079687365372222456778186655567720875215087517062784172594547271728515625e-38
     76#define FLT_MAX 340282346638528859811704183484516925440
     77
     78/* double limits */
     79#define DBL_MIN 2.2250738585072013830902327173324040642192159804623318305533274168872044348139181958542831590125110205640673397310358110051524341615534601088560123853777188211307779935320023304796101474425836360719216e-308
     80#define DBL_MAX 1.7976931348623157081452742373170435679807056752584499659891747680315726078002853876058955863276687817154045895351438246423432132688946418276846754670353751698604991057655128207624549009038932894407587e+308
     81
     82/* long double limits */
     83#define LDBL_MIN 3.3621031431120935062626778173217526025980793448464712401088272298087426993907289670430927063650562228625019066688234732270901114717276781407474941951906317291667263914849985862188944930687409323125832e-4932L
     84#define LDBL_MAX 1.1897314953572317650212638530309702051690633222946242004403237338917370055229707226164102903365288828535456978074955773144274431536702884341981255738537436786735932007069732632019159182829615243655295e+4932L
     85
     86/* epsilons */
     87#define FLT_EPSILON 1.1920928955078125e-07
     88#define DBL_EPSILON 2.220446049250313080847263336181640625e-16
     89#define LDBL_EPSILON 1.08420217248550443400745280086994171142578125e-19L
     90
     91/* float radix */
     92#define FLT_RADIX 2
     93
     94/* mantisa */
     95#define FLT_MANT_DIG 24
     96#define DBL_MANT_DIG 53
     97#define LDBL_MANT_DIG 64
     98
     99/* exponents */
     100#define DBL_MIN_EXP -1021
     101#define DBL_MAX_EXP 1024
     102
    63103#endif
     104
     105#endif /* __GNUC__ */
    64106
    65107#endif /* POSIX_FLOAT_H_ */

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

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    3636#define POSIX_MATH_H_
    3737
     38#ifndef __POSIX_DEF__
     39#define __POSIX_DEF__(x) x
     40#endif
     41
    3842#ifdef __GNUC__
    3943        #define HUGE_VAL (__builtin_huge_val())
    … …  
    4145
    4246/* Normalization Functions */
    43 extern double posix_ldexp(double x, int exp);
    44 extern double posix_frexp(double num, int *exp);
     47extern double __POSIX_DEF__(ldexp)(double x, int exp);
     48extern double __POSIX_DEF__(frexp)(double num, int *exp);
    4549
    46 double posix_fabs(double x);
    47 double posix_floor(double x);
    48 double posix_modf(double x, double *iptr);
    49 double posix_fmod(double x, double y);
    50 double posix_pow(double x, double y);
    51 double posix_exp(double x);
    52 double posix_sqrt(double x);
    53 double posix_log(double x);
    54 double posix_sin(double x);
    55 double posix_cos(double x);
    56 double posix_atan2(double y, double x);
    57 
    58 #ifndef LIBPOSIX_INTERNAL
    59         #define ldexp posix_ldexp
    60         #define frexp posix_frexp
    61 
    62         #define fabs posix_fabs
    63         #define floor posix_floor
    64         #define modf posix_modf
    65         #define fmod posix_fmod
    66         #define pow posix_pow
    67         #define exp posix_exp
    68         #define sqrt posix_sqrt
    69         #define log posix_log
    70         #define sin posix_sin
    71         #define cos posix_cos
    72         #define atan2 posix_atan2
    73 #endif
     50double __POSIX_DEF__(fabs)(double x);
     51double __POSIX_DEF__(floor)(double x);
     52double __POSIX_DEF__(modf)(double x, double *iptr);
     53double __POSIX_DEF__(fmod)(double x, double y);
     54double __POSIX_DEF__(pow)(double x, double y);
     55double __POSIX_DEF__(exp)(double x);
     56double __POSIX_DEF__(sqrt)(double x);
     57double __POSIX_DEF__(log)(double x);
     58double __POSIX_DEF__(sin)(double x);
     59double __POSIX_DEF__(cos)(double x);
     60double __POSIX_DEF__(atan2)(double y, double x);
    7461
    7562#endif /* POSIX_MATH_H_ */

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

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    3636#define POSIX_SIGNAL_H_
    3737
     38#ifndef __POSIX_DEF__
     39#define __POSIX_DEF__(x) x
     40#endif
     41
    3842#include "sys/types.h"
     43#include <posix/ucontext.h>
    3944
    4045extern void __posix_default_signal_handler(int signo);
    … …  
    5156#define SIG_IGN ((void (*)(int)) __posix_ignore_signal_handler)
    5257
    53 typedef int posix_sig_atomic_t;
    54 typedef uint32_t posix_sigset_t;
    55 typedef struct posix_mcontext {
    56         /* must not be empty to avoid compiler warnings (-pedantic) */
    57         int dummy;
    58 } posix_mcontext_t;
    59 
    60 union posix_sigval {
    61         int sival_int;
    62         void *sival_ptr;
    63 };
    64 
    65 struct posix_sigevent {
    66         int sigev_notify; /* Notification type. */
    67         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. */
    71 };
    7258
    7359typedef struct {
    … …  
    7763        int si_errno;
    7864
    79         posix_pid_t si_pid;
    80         posix_uid_t si_uid;
     65        __POSIX_DEF__(pid_t) si_pid;
     66        __POSIX_DEF__(uid_t) si_uid;
    8167        void *si_addr;
    8268        int si_status;
    … …  
    8470        long si_band;
    8571
    86         union posix_sigval si_value;
    87 } posix_siginfo_t;
    88 
    89 struct posix_sigaction {
     72        union __POSIX_DEF__(sigval) si_value;
     73} __POSIX_DEF__(siginfo_t);
     74
     75struct __POSIX_DEF__(sigaction) {
    9076        void (*sa_handler)(int);
    91         posix_sigset_t sa_mask;
     77        __POSIX_DEF__(sigset_t) sa_mask;
    9278        int sa_flags;
    93         void (*sa_sigaction)(int, posix_siginfo_t *, void *);
     79        void (*sa_sigaction)(int, __POSIX_DEF__(siginfo_t) *, void *);
    9480};
    9581
    96 typedef struct {
    97         void *ss_sp;
    98         size_t ss_size;
    99         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 */
     82
     83/* Values of __POSIX_DEF__(sigevent)::sigev_notify */
    11084#undef SIGEV_NONE
    11185#undef SIGEV_SIGNAL
    … …  
    255229};
    256230
    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
     231extern int __POSIX_DEF__(sigaction)(int sig, const struct __POSIX_DEF__(sigaction) *restrict act,
     232    struct __POSIX_DEF__(sigaction) *restrict oact);
     233
     234extern void (*__POSIX_DEF__(signal)(int sig, void (*func)(int)))(int);
     235extern int __POSIX_DEF__(raise)(int sig);
     236extern int __POSIX_DEF__(kill)(__POSIX_DEF__(pid_t) pid, int sig);
     237extern int __POSIX_DEF__(killpg)(__POSIX_DEF__(pid_t) pid, int sig);
     238
     239extern void __POSIX_DEF__(psiginfo)(const __POSIX_DEF__(siginfo_t) *pinfo, const char *message);
     240extern void __POSIX_DEF__(psignal)(int signum, const char *message);
     241
     242extern int __POSIX_DEF__(sigemptyset)(__POSIX_DEF__(sigset_t) *set);
     243extern int __POSIX_DEF__(sigfillset)(__POSIX_DEF__(sigset_t) *set);
     244extern int __POSIX_DEF__(sigaddset)(__POSIX_DEF__(sigset_t) *set, int signo);
     245extern int __POSIX_DEF__(sigdelset)(__POSIX_DEF__(sigset_t) *set, int signo);
     246extern int __POSIX_DEF__(sigismember)(const __POSIX_DEF__(sigset_t) *set, int signo);
     247
     248extern int __POSIX_DEF__(thread_sigmask)(int how, const __POSIX_DEF__(sigset_t) *restrict set,
     249    __POSIX_DEF__(sigset_t) *restrict oset);
     250extern int __POSIX_DEF__(sigprocmask)(int how, const __POSIX_DEF__(sigset_t) *restrict set,
     251    __POSIX_DEF__(sigset_t) *restrict oset);
     252
    310253
    311254#endif /* POSIX_SIGNAL_H_ */

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

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    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"
    … …  
    108117extern size_t fwrite(const void *, size_t, size_t, FILE *);
    109118
    110 extern int fseek(FILE *, off64_t, int);
    111119extern void rewind(FILE *);
    112 extern off64_t ftell(FILE *);
    113120extern int feof(FILE *);
    114121extern int fileno(FILE *);
    … …  
    126133#undef L_ctermid
    127134#define L_ctermid PATH_MAX
    128 extern char *posix_ctermid(char *s);
     135extern char *__POSIX_DEF__(ctermid)(char *s);
    129136
    130137/* Error Recovery */
    131 extern void posix_clearerr(FILE *stream);
     138extern void __POSIX_DEF__(clearerr)(FILE *stream);
    132139
    133140/* Input/Output */
    134141#undef putc
    135142#define putc fputc
    136 extern int posix_fputs(const char *restrict s, FILE *restrict stream);
     143extern int __POSIX_DEF__(fputs)(const char *restrict s, FILE *restrict stream);
    137144#undef getc
    138145#define getc fgetc
    139 extern int posix_ungetc(int c, FILE *stream);
    140 extern ssize_t posix_getdelim(char **restrict lineptr, size_t *restrict n,
     146extern int __POSIX_DEF__(ungetc)(int c, FILE *stream);
     147extern ssize_t __POSIX_DEF__(getdelim)(char **restrict lineptr, size_t *restrict n,
    141148    int delimiter, FILE *restrict stream);
    142 extern ssize_t posix_getline(char **restrict lineptr, size_t *restrict n,
     149extern ssize_t __POSIX_DEF__(getline)(char **restrict lineptr, size_t *restrict n,
    143150    FILE *restrict stream);
    144151
    145152/* Opening Streams */
    146 extern FILE *posix_freopen(const char *restrict filename,
     153extern FILE *__POSIX_DEF__(freopen)(const char *restrict filename,
    147154    const char *restrict mode, FILE *restrict stream);
    148155
    149156/* Error Messages */
    150 extern void posix_perror(const char *s);
     157extern void __POSIX_DEF__(perror)(const char *s);
    151158
    152159/* File Positioning */
    153 typedef struct _posix_fpos posix_fpos_t;
    154 extern int posix_fsetpos(FILE *stream, const posix_fpos_t *pos);
    155 extern int posix_fgetpos(FILE *restrict stream, posix_fpos_t *restrict pos);
    156 extern int posix_fseek(FILE *stream, long offset, int whence);
    157 extern int posix_fseeko(FILE *stream, posix_off_t offset, int whence);
    158 extern long posix_ftell(FILE *stream);
    159 extern posix_off_t posix_ftello(FILE *stream);
     160typedef struct _posix_fpos __POSIX_DEF__(fpos_t);
     161extern int __POSIX_DEF__(fsetpos)(FILE *stream, const __POSIX_DEF__(fpos_t) *pos);
     162extern int __POSIX_DEF__(fgetpos)(FILE *restrict stream, __POSIX_DEF__(fpos_t) *restrict pos);
     163extern int __POSIX_DEF__(fseek)(FILE *stream, long offset, int whence);
     164extern int __POSIX_DEF__(fseeko)(FILE *stream, __POSIX_DEF__(off_t) offset, int whence);
     165extern long __POSIX_DEF__(ftell)(FILE *stream);
     166extern __POSIX_DEF__(off_t) __POSIX_DEF__(ftello)(FILE *stream);
    160167
    161168/* Flushing Buffers */
    162 extern int posix_fflush(FILE *stream);
     169extern int __POSIX_DEF__(fflush)(FILE *stream);
    163170
    164171/* Formatted Output */
    165 extern int posix_dprintf(int fildes, const char *restrict format, ...)
     172extern int __POSIX_DEF__(dprintf)(int fildes, const char *restrict format, ...)
    166173    PRINTF_ATTRIBUTE(2, 3);
    167 extern int posix_vdprintf(int fildes, const char *restrict format, va_list ap);
    168 extern int posix_sprintf(char *restrict s, const char *restrict format, ...)
     174extern int __POSIX_DEF__(vdprintf)(int fildes, const char *restrict format, va_list ap);
     175extern int __POSIX_DEF__(sprintf)(char *restrict s, const char *restrict format, ...)
    169176    PRINTF_ATTRIBUTE(2, 3);
    170 extern int posix_vsprintf(char *restrict s, const char *restrict format, va_list ap);
     177extern int __POSIX_DEF__(vsprintf)(char *restrict s, const char *restrict format, va_list ap);
    171178
    172179/* Formatted Input */
    173 extern int posix_fscanf(
     180extern int __POSIX_DEF__(fscanf)(
    174181    FILE *restrict stream, const char *restrict format, ...);
    175 extern int posix_vfscanf(
     182extern int __POSIX_DEF__(vfscanf)(
    176183    FILE *restrict stream, const char *restrict format, va_list arg);
    177 extern int posix_scanf(const char *restrict format, ...);
    178 extern int posix_vscanf(const char *restrict format, va_list arg);
    179 extern int posix_sscanf(
     184extern int __POSIX_DEF__(scanf)(const char *restrict format, ...);
     185extern int __POSIX_DEF__(vscanf)(const char *restrict format, va_list arg);
     186extern int __POSIX_DEF__(sscanf)(
    180187    const char *restrict s, const char *restrict format, ...);
    181 extern int posix_vsscanf(
     188extern int __POSIX_DEF__(vsscanf)(
    182189    const char *restrict s, const char *restrict format, va_list arg);
    183190
    184191/* File Locking */
    185 extern void posix_flockfile(FILE *file);
    186 extern int posix_ftrylockfile(FILE *file);
    187 extern void posix_funlockfile(FILE *file);
    188 extern int posix_getc_unlocked(FILE *stream);
    189 extern int posix_getchar_unlocked(void);
    190 extern int posix_putc_unlocked(int c, FILE *stream);
    191 extern int posix_putchar_unlocked(int c);
     192extern void __POSIX_DEF__(flockfile)(FILE *file);
     193extern int __POSIX_DEF__(ftrylockfile)(FILE *file);
     194extern void __POSIX_DEF__(funlockfile)(FILE *file);
     195extern int __POSIX_DEF__(getc_unlocked)(FILE *stream);
     196extern int __POSIX_DEF__(getchar_unlocked)(void);
     197extern int __POSIX_DEF__(putc_unlocked)(int c, FILE *stream);
     198extern int __POSIX_DEF__(putchar_unlocked)(int c);
    192199
    193200/* Deleting Files */
    194 extern int posix_remove(const char *path);
     201extern int __POSIX_DEF__(remove)(const char *path);
    195202
    196203/* Renaming Files */
    197 extern int posix_rename(const char *old, const char *new);
     204extern int __POSIX_DEF__(rename)(const char *oldname, const char *newname);
    198205
    199206/* Temporary Files */
    200207#undef L_tmpnam
    201208#define L_tmpnam PATH_MAX
    202 extern char *posix_tmpnam(char *s);
    203 extern char *posix_tempnam(const char *dir, const char *pfx);
    204 extern FILE *posix_tmpfile(void);
    205 
    206 #ifndef LIBPOSIX_INTERNAL
    207         /* DEBUG macro does not belong to POSIX stdio.h. Its unconditional
    208          * definition in the native stdio.h causes unexpected behaviour of
    209          * applications which uses their own DEBUG macro (e.g. debugging
    210          * output is printed even if not desirable). */
    211         #undef DEBUG
    212 
    213         #define ctermid posix_ctermid
    214 
    215         #define clearerr posix_clearerr
    216 
    217         #define fputs posix_fputs
    218         #define ungetc posix_ungetc
    219         #define getdelim posix_getdelim
    220         #define getline posix_getline
    221 
    222         #define freopen posix_freopen
    223 
    224         #define perror posix_perror
    225 
    226         #define fpos_t posix_fpos_t
    227         #define fsetpos posix_fsetpos
    228         #define fgetpos posix_fgetpos
    229         #define fseek posix_fseek
    230         #define fseeko posix_fseeko
    231         #define ftell posix_ftell
    232         #define ftello posix_ftello
    233 
    234         #define fflush posix_fflush
    235 
    236         #define dprintf posix_dprintf
    237         #define vdprintf posix_vdprintf
    238         #define sprintf posix_sprintf
    239         #define vsprintf posix_vsprintf
    240 
    241         #define fscanf posix_fscanf
    242         #define vfscanf posix_vfscanf
    243         #define vscanf posix_vscanf
    244         #define scanf posix_scanf
    245         #define sscanf posix_sscanf
    246         #define vsscanf posix_vsscanf
    247 
    248         #define flockfile posix_flockfile
    249         #define ftrylockfile posix_ftrylockfile
    250         #define funlockfile posix_funlockfile
    251 
    252         #define getc_unlocked posix_getc_unlocked
    253         #define getchar_unlocked posix_getchar_unlocked
    254         #define putc_unlocked posix_putc_unlocked
    255         #define putchar_unlocked posix_putchar_unlocked
    256 
    257         #define remove posix_remove
    258 
    259         #define rename posix_rename
    260 
    261         #define tmpnam posix_tmpnam
    262         #define tempnam posix_tempnam
    263         #define tmpfile posix_tmpfile
    264 #endif
     209extern char *__POSIX_DEF__(tmpnam)(char *s);
     210extern char *__POSIX_DEF__(tempnam)(const char *dir, const char *pfx);
     211extern FILE *__POSIX_DEF__(tmpfile)(void);
     212
    265213
    266214#endif /* POSIX_STDIO_H_ */

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

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    3737#define POSIX_STRINGS_H_
    3838
     39#ifndef __POSIX_DEF__
     40#define __POSIX_DEF__(x) x
     41#endif
     42
     43
     44#include <libarch/types.h>
     45
    3946/* Search Functions */
    4047#ifndef POSIX_STRING_H_
    41 extern int posix_ffs(int i);
     48extern int __POSIX_DEF__(ffs)(int i);
    4249#endif
    4350
    4451/* String/Array Comparison */
    4552#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);
     53extern int __POSIX_DEF__(strcasecmp)(const char *s1, const char *s2);
     54extern int __POSIX_DEF__(strncasecmp)(const char *s1, const char *s2, size_t n);
    4855#endif
    4956
    … …  
    5562
    5663/* 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);
     64extern int __POSIX_DEF__(bcmp)(const void *mem1, const void *mem2, size_t n);
     65extern void __POSIX_DEF__(bcopy)(const void *src, void *dest, size_t n);
     66extern void __POSIX_DEF__(bzero)(void *mem, size_t n);
     67extern char *__POSIX_DEF__(index)(const char *s, int c);
     68extern char *__POSIX_DEF__(rindex)(const char *s, int c);
    6269
    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
    7670
    7771#endif  // POSIX_STRINGS_H_

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

    r30c1b75 rc8bb1633  
    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>
    … …  
    4549#define MAP_FIXED      (1 << 2)
    4650#define MAP_ANONYMOUS  (1 << 3)
     51#define MAP_ANON MAP_ANONYMOUS
    4752
    4853#undef PROT_NONE
    … …  
    5661
    5762extern void *mmap(void *start, size_t length, int prot, int flags, int fd,
    58     posix_off_t offset);
     63    __POSIX_DEF__(off_t) offset);
    5964extern int munmap(void *start, size_t length);
     65
    6066
    6167#endif /* POSIX_SYS_MMAN_H_ */

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

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    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
     148/* Issue alarm signal. */
     149extern unsigned int __POSIX_DEF__(alarm)(unsigned int);
    188150
    189151#endif /* POSIX_UNISTD_H_ */

  • uspace/lib/posix/source/ctype.c

    r30c1b75 rc8bb1633  
    3535
    3636#define LIBPOSIX_INTERNAL
     37#define __POSIX_DEF__(x) posix_##x
    3738
    3839#include "posix/ctype.h"

  • uspace/lib/posix/source/errno.c

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    3434
    3535#define LIBPOSIX_INTERNAL
     36#define __POSIX_DEF__(x) posix_##x
    3637
    3738#include "internal/common.h"

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

    r30c1b75 rc8bb1633  
    4343
    4444#define LIBPOSIX_INTERNAL
     45#define __POSIX_DEF__(x) posix_##x
    4546
    4647#include "libc/stdbool.h"

  • uspace/lib/posix/source/getopt.c

    r30c1b75 rc8bb1633  
    3333 */
    3434#define LIBPOSIX_INTERNAL
     35#define __POSIX_DEF__(x) posix_##x
    3536
    3637#include "internal/common.h"

  • uspace/lib/posix/source/locale.c

    r30c1b75 rc8bb1633  
    3434
    3535#define LIBPOSIX_INTERNAL
     36#define __POSIX_DEF__(x) posix_##x
    3637
    3738#include "internal/common.h"

  • uspace/lib/posix/source/math.c

    r30c1b75 rc8bb1633  
    3434
    3535#define LIBPOSIX_INTERNAL
     36#define __POSIX_DEF__(x) posix_##x
    3637
    3738#include "internal/common.h"

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

    r30c1b75 rc8bb1633  
    3434
    3535#define LIBPOSIX_INTERNAL
     36#define __POSIX_DEF__(x) posix_##x
    3637
    3738#include "libc/stdbool.h"

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

    r30c1b75 rc8bb1633  
    3434
    3535#define LIBPOSIX_INTERNAL
     36#define __POSIX_DEF__(x) posix_##x
    3637
    3738#include "posix/signal.h"

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

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    3434
    3535#define LIBPOSIX_INTERNAL
     36#define __POSIX_DEF__(x) posix_##x
    3637
    3738#include "posix/assert.h"

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

    r30c1b75 rc8bb1633  
    3535
    3636#define LIBPOSIX_INTERNAL
     37#define __POSIX_DEF__(x) posix_##x
    3738
    3839#include "internal/common.h"
    … …  
    6263        // TODO: low priority, just a compile-time dependency of binutils
    6364        not_implemented();
     65        return 1;
    6466}
    6567
    … …  
    231233        // TODO: low priority, just a compile-time dependency of binutils
    232234        not_implemented();
     235        return 0;
    233236}
    234237
    … …  
    243246int posix_system(const char *string) {
    244247        // TODO: does nothing at the moment
     248        not_implemented();
    245249        return 0;
    246250}

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

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    3434
    3535#define LIBPOSIX_INTERNAL
     36#define __POSIX_DEF__(x) posix_##x
    3637
    3738#include "../internal/common.h"

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

    r30c1b75 rc8bb1633  
    3535
    3636#define LIBPOSIX_INTERNAL
     37#define __POSIX_DEF__(x) posix_##x
    3738
    3839#include "internal/common.h"

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

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    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

    r30c1b75 rc8bb1633  
    3535
    3636#define LIBPOSIX_INTERNAL
     37#define __POSIX_DEF__(x) posix_##x
    3738
    3839#include "../internal/common.h"

  • uspace/lib/posix/source/time.c

    r30c1b75 rc8bb1633  
    3535
    3636#define LIBPOSIX_INTERNAL
     37#define __POSIX_DEF__(x) posix_##x
    3738
    3839#include "internal/common.h"

  • uspace/lib/posix/source/unistd.c

    r30c1b75 rc8bb1633  
    3535
    3636#define LIBPOSIX_INTERNAL
     37#define __POSIX_DEF__(x) posix_##x
    3738
    3839#include "internal/common.h"
    … …  
    421422}
    422423
     424unsigned int posix_alarm(unsigned int seconds)
     425{
     426        not_implemented();
     427        return 0;
     428}
     429
    423430/** @}
    424431 */
Note: See TracChangeset for help on using the changeset viewer.