Changes in / [df956b9b:06b0211b] in mainline


Ignore:
Location:
uspace
Files:
3 added
49 edited

Legend:

Unmodified
Added
Removed

  • uspace/Makefile.common

    rdf956b9b r06b0211b  
    219219endif
    220220
    221 ## Setup platform configuration
    222 #
    223 
    224 -include $(LIBC_PREFIX)/arch/$(UARCH)/Makefile.common
    225 
    226 ## Compilation options
    227 #
    228 
    229 JOBFILE = $(LIBC_PREFIX)/../../../tools/jobfile.py
    230 
     221# Prepare for POSIX before including platform specific stuff
    231222ifeq ($(POSIX_COMPAT),y)
    232223        CFLAGS = -I$(LIBPOSIX_PREFIX)/include/posix  -I$(LIBPOSIX_PREFIX)/include/
    233         LIBS += $(LIBPOSIX_PREFIX)/libposix.a
    234 endif
     224        BASE_LIBS = $(LIBPOSIX_PREFIX)/libposixaslibc.a $(LIBPOSIX_PREFIX)/libc4posix.a $(LIBSOFTINT_PREFIX)/libsoftint.a
     225endif
     226
     227## Setup platform configuration
     228#
     229
     230-include $(LIBC_PREFIX)/arch/$(UARCH)/Makefile.common
     231
     232## Compilation options
     233#
     234
     235JOBFILE = $(LIBC_PREFIX)/../../../tools/jobfile.py
    235236
    236237ifeq ($(COMPILER),gcc_cross)

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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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/generic/io/io.c

    rdf956b9b r06b0211b  
    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/stdio.h

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

  • uspace/lib/posix/Makefile

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

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

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

    rdf956b9b r06b0211b  
    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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    rdf956b9b r06b0211b  
    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

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

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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

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

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

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

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

    rdf956b9b r06b0211b  
    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

    rdf956b9b r06b0211b  
    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

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

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

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

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

    rdf956b9b r06b0211b  
    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.