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

Changeset 0ffbed9 in mainline


Ignore:
Timestamp:
2011-06-19T17:49:29Z (11 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master
Children:
5974661
Parents:
f48b637 (diff), 32fb6944 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge libposix.

Location:
uspace/lib/posix
Files:
12 added
18 edited
1 moved

Legend:

Unmodified
Added
Removed
  • uspace/lib/posix/Makefile

    rf48b637 r0ffbed9  
    4040SOURCES = \
    4141        ctype.c \
     42        getopt.c \
    4243        stdio.c \
    4344        stdlib.c \
     45        stdlib/strtold.c \
    4446        string.c \
    4547        strings.c \
  • uspace/lib/posix/ctype.c

    rf48b637 r0ffbed9  
    11/*
    22 * Copyright (c) 2011 Jiri Zarevucky
     3 * Copyright (c) 2011 Petr Koupy
    34 * All rights reserved.
    45 *
     
    2728 */
    2829
     30/** @addtogroup libposix
     31 * @{
     32 */
     33/** @file
     34 */
     35
     36#define LIBPOSIX_INTERNAL
     37
    2938#include "ctype.h"
    3039
    31 int isxdigit(int ch)
     40/**
     41 *
     42 * @param ch
     43 * @return
     44 */
     45int posix_isxdigit(int ch)
    3246{
    3347        return isdigit(ch) ||
    34                (ch >= 'a' && ch <= 'f') ||
    35                (ch >= 'A' && ch <= 'F');
     48            (ch >= 'a' && ch <= 'f') ||
     49            (ch >= 'A' && ch <= 'F');
    3650}
    3751
     52/** @}
     53 */
  • uspace/lib/posix/ctype.h

    rf48b637 r0ffbed9  
    11/*
    22 * Copyright (c) 2011 Jiri Zarevucky
     3 * Copyright (c) 2011 Petr Koupy
    34 * All rights reserved.
    45 *
     
    2728 */
    2829
     30/** @addtogroup libposix
     31 * @{
     32 */
     33/** @file
     34 */
     35
    2936#ifndef POSIX_CTYPE_H_
    3037#define POSIX_CTYPE_H_
     
    3239#include "libc/ctype.h"
    3340
    34 extern int isxdigit(int ch);
     41/* Classification of Characters */
     42extern int posix_isxdigit(int ch);
     43
     44#ifndef LIBPOSIX_INTERNAL
     45        #define isxdigit posix_isxdigit
     46#endif
    3547
    3648#endif /* POSIX_CTYPE_H_ */
    3749
     50/** @}
     51 */
  • uspace/lib/posix/internal/common.h

    rf48b637 r0ffbed9  
    2727 */
    2828
     29/** @addtogroup libposix
     30 * @{
     31 */
     32/** @file
     33 */
     34
    2935#ifndef LIBPOSIX_COMMON_H_
    3036#define LIBPOSIX_COMMON_H_
     
    3339#include <stdlib.h>
    3440
    35 #define not_implemented() (fprintf(stderr, "Function %s() in file %s at line %d is not implemented\n", __func__, __FILE__, __LINE__), abort())
     41#define not_implemented() (fprintf(stderr, \
     42    "Function %s() in file %s at line %d is not implemented\n", \
     43    __func__, __FILE__, __LINE__), abort())
    3644
    3745#endif /* LIBPOSIX_COMMON_H_ */
    3846
     47/** @}
     48 */
  • uspace/lib/posix/signal.h

    rf48b637 r0ffbed9  
    2727 */
    2828
     29/** @addtogroup libposix
     30 * @{
     31 */
     32/** @file
     33 */
     34
    2935#ifndef POSIX_SIGNAL_H_
    3036#define POSIX_SIGNAL_H_
    3137
    32 #include <errno.h>
     38#include "libc/errno.h"
    3339
    3440/* HelenOS doesn't have signals, so calls to functions of this header
     
    4147 */
    4248
     49#undef SIG_DFL
    4350#define SIG_DFL ((void (*)(int)) 0)
     51#undef SIG_ERR
    4452#define SIG_ERR ((void (*)(int)) 0)
     53#undef SIG_IGN
    4554#define SIG_IGN ((void (*)(int)) 0)
    4655
    4756#define signal(sig,func) (errno = ENOTSUP, SIG_ERR)
    48 #define raise(sig) ((int)-1)
     57#define raise(sig) ((int) -1)
    4958
    50 typedef int sig_atomic_t;
     59typedef int posix_sig_atomic_t;
    5160
    5261/* full POSIX set */
     
    8291};
    8392
     93#ifndef LIBPOSIX_INTERNAL
     94        #define sig_atomic_t posix_sig_atomic_t
     95#endif
     96
    8497#endif /* POSIX_SIGNAL_H_ */
    8598
     99/** @}
     100 */
  • uspace/lib/posix/stdio.c

    rf48b637 r0ffbed9  
    11/*
    22 * Copyright (c) 2011 Jiri Zarevucky
     3 * Copyright (c) 2011 Petr Koupy
    34 * All rights reserved.
    45 *
     
    3334 */
    3435
    35 #define POSIX_INTERNAL
     36#define LIBPOSIX_INTERNAL
    3637
    3738#include <assert.h>
    38 #include "errno.h"
    39 #include "common.h"
     39#include <errno.h>
     40
     41#include "internal/common.h"
    4042#include "stdio.h"
    4143#include "string.h"
     44
    4245/* not the best of solutions, but freopen will eventually
    43    need to be implemented in libc anyway */
     46 * need to be implemented in libc anyway
     47 */
    4448#include "../c/generic/private/stdio.h"
    4549
    46 FILE *posix_freopen(const char *restrict filename,
    47                     const char *restrict mode,
    48                     FILE *restrict stream)
     50/**
     51 *
     52 * @param c
     53 * @param stream
     54 * @return
     55 */
     56int posix_ungetc(int c, FILE *stream)
     57{
     58        // TODO
     59        not_implemented();
     60}
     61
     62/**
     63 *
     64 * @param filename
     65 * @param mode
     66 * @param stream
     67 * @return
     68 */
     69FILE *posix_freopen(
     70    const char *restrict filename,
     71    const char *restrict mode,
     72    FILE *restrict stream)
    4973{
    5074        assert(mode != NULL);
     
    5579               
    5680                /* print error to stderr as well, to avoid hard to find problems
    57                    with buggy apps that expect this to work */
    58                 fprintf(stderr, "ERROR: Application wants to use freopen() to change mode of opened stream.\n"
    59                                 "       libposix does not support that yet, the application may function improperly.\n");
     81                 * with buggy apps that expect this to work
     82                 */
     83                fprintf(stderr,
     84                    "ERROR: Application wants to use freopen() to change mode of opened stream.\n"
     85                    "       libposix does not support that yet, the application may function improperly.\n");
    6086                errno = ENOTSUP;
    6187                return NULL;
     
    6894        }
    6995        memcpy(copy, stream, sizeof(FILE));
    70         fclose(copy);   /* copy is now freed */
     96        fclose(copy); /* copy is now freed */
    7197       
    72         copy = fopen(filename, mode);         /* open new stream */
     98        copy = fopen(filename, mode); /* open new stream */
    7399        if (copy == NULL) {
    74100                /* fopen() sets errno */
     
    87113}
    88114
     115/**
     116 *
     117 * @param s
     118 */
    89119void posix_perror(const char *s)
     120{
     121        // TODO
     122        not_implemented();
     123}
     124
     125/**
     126 *
     127 * @param stream
     128 * @param offset
     129 * @param whence
     130 * @return
     131 */
     132int posix_fseeko(FILE *stream, posix_off_t offset, int whence)
     133{
     134        // TODO
     135        not_implemented();
     136}
     137
     138/**
     139 *
     140 * @param stream
     141 * @return
     142 */
     143posix_off_t posix_ftello(FILE *stream)
     144{
     145        // TODO
     146        not_implemented();
     147}
     148
     149/**
     150 *
     151 * @param s
     152 * @param format
     153 * @param ...
     154 * @return
     155 */
     156int posix_sprintf(char *s, const char *format, ...)
     157{
     158        // TODO
     159        not_implemented();
     160}
     161
     162/**
     163 *
     164 * @param s
     165 * @param format
     166 * @param ...
     167 * @return
     168 */
     169int posix_sscanf(const char *s, const char *format, ...)
    90170{
    91171        // TODO
     
    95175/** @}
    96176 */
    97 
  • uspace/lib/posix/stdio.h

    rf48b637 r0ffbed9  
    11/*
    22 * Copyright (c) 2011 Jiri Zarevucky
     3 * Copyright (c) 2011 Petr Koupy
    34 * All rights reserved.
    45 *
     
    2728 */
    2829
     30/** @addtogroup libposix
     31 * @{
     32 */
     33/** @file
     34 */
     35
    2936#ifndef POSIX_STDIO_H_
    3037#define POSIX_STDIO_H_
    3138
    3239#include "libc/stdio.h"
     40#include "sys/types.h"
    3341
     42/* Character Input/Output */
    3443#define putc fputc
    3544#define getc fgetc
     45extern int posix_ungetc(int c, FILE *stream);
    3646
     47/* Opening Streams */
     48extern FILE *posix_freopen(
     49   const char *restrict filename,
     50   const char *restrict mode,
     51   FILE *restrict stream);
    3752
    38 extern FILE *posix_freopen(const char *restrict filename,
    39                            const char *restrict mode,
    40                            FILE *restrict stream);
    41 
     53/* Error Messages */
    4254extern void posix_perror(const char *s);
    4355
    44 #ifndef POSIX_INTERNAL
     56/* File Positioning */
     57extern int posix_fseeko(FILE *stream, posix_off_t offset, int whence);
     58extern posix_off_t posix_ftello(FILE *stream);
     59
     60/* Formatted Input/Output */
     61extern int posix_sprintf(char *restrict s, const char *restrict format, ...);
     62extern int posix_sscanf(const char *restrict s, const char *restrict format, ...);
     63
     64#ifndef LIBPOSIX_INTERNAL
     65        #define ungetc posix_ungetc
     66
    4567        #define freopen posix_freopen
     68
    4669        #define perror posix_perror
     70
     71        #define fseeko posix_fseeko
     72        #define ftello posix_ftello
     73
     74        #define sprintf posix_sprintf
     75        #define sscanf posix_sscanf
    4776#endif
    4877
    4978#endif /* POSIX_STDIO_H_ */
    5079
     80/** @}
     81 */
  • uspace/lib/posix/stdlib.c

    rf48b637 r0ffbed9  
    3737
    3838#include "stdlib.h"
    39 #include "common.h"
     39#include "internal/common.h"
    4040
    4141/**
     
    4646 * @param compare
    4747 */
    48 void posix_qsort(void *array, size_t count, size_t size, int (*compare)(const void *, const void *))
     48void posix_qsort(void *array, size_t count, size_t size,
     49    int (*compare)(const void *, const void *))
    4950{
    5051        // TODO
     
    7677
    7778/**
    78  *
     79 * Converts a string representation of a floating-point number to
     80 * its native representation. See posix_strtold().
     81 *
    7982 * @param nptr
    8083 * @param endptr
     
    8386float posix_strtof(const char *restrict nptr, char **restrict endptr)
    8487{
    85         // TODO
    86         not_implemented();
     88        return (float) posix_strtold(nptr, endptr);
    8789}
    8890
    8991/**
    90  *
     92 * Converts a string representation of a floating-point number to
     93 * its native representation. See posix_strtold().
     94 *
    9195 * @param nptr
    9296 * @param endptr
     
    9599double posix_strtod(const char *restrict nptr, char **restrict endptr)
    96100{
    97         // TODO
    98         not_implemented();
    99 }
    100 
    101 /**
    102  *
    103  * @param nptr
    104  * @param endptr
    105  * @return
    106  */
    107 long double posix_strtold(const char *restrict nptr, char **restrict endptr)
    108 {
    109         // TODO
    110         not_implemented();
     101        return (double) posix_strtold(nptr, endptr);
    111102}
    112103
  • uspace/lib/posix/stdlib.h

    rf48b637 r0ffbed9  
    4343#endif
    4444
     45/* Process Termination */
    4546#undef EXIT_FAILURE
    4647#define EXIT_FAILURE 1
    4748#undef EXIT_SUCCESS
    4849#define EXIT_SUCCESS 0
    49 
    50 #define _exit exit
    5150#define _Exit exit
    5251
    5352/* Array Sort Function */
    54 extern void posix_qsort(void *array, size_t count, size_t size, int (*compare)(const void *, const void *));
     53extern void posix_qsort(void *array, size_t count, size_t size,
     54    int (*compare)(const void *, const void *));
    5555
    5656/* Environment Access */
     
    6060extern char *posix_realpath(const char *restrict name, char *restrict resolved);
    6161
    62 /* decimal to native floating point conversion */
     62/* Floating Point Conversion */
    6363extern float posix_strtof(const char *restrict nptr, char **restrict endptr);
    6464extern double posix_strtod(const char *restrict nptr, char **restrict endptr);
    6565extern long double posix_strtold(const char *restrict nptr, char **restrict endptr);
    6666
    67 /* decimal to native integer conversion */
     67/* Integer Conversion */
    6868extern int posix_atoi(const char *str);
    6969
  • uspace/lib/posix/string.c

    rf48b637 r0ffbed9  
    4343#include <errno.h>
    4444
    45 /* Defined for convenience. Returns pointer to the terminating nul character.
     45/**
     46 * Defined for convenience. Returns pointer to the terminating nul character.
     47 *
     48 * @param s
     49 * @return
    4650 */
    4751static char *strzero(const char *s)
    4852{
    49         while (*s != '\0')
    50                 s ++;
    51 
    52         return (char*) s;
    53 }
    54 
    55 /* Returns true if s2 is a prefix of s1.
     53        while (*s != '\0') {
     54                s++;
     55        }
     56
     57        return (char *) s;
     58}
     59
     60/**
     61 * Returns true if s2 is a prefix of s1.
     62 *
     63 * @param s1
     64 * @param s2
     65 * @return
    5666 */
    5767static bool begins_with(const char *s1, const char *s2)
    5868{
    5969        while (*s1 == *s2 && *s2 != '\0') {
    60                 s1 ++;
    61                 s2 ++;
     70                s1++;
     71                s2++;
    6272        }
    6373       
     
    6676}
    6777
    68 /* The same as strpbrk, except it returns pointer to the nul terminator
     78/**
     79 * The same as strpbrk, except it returns pointer to the nul terminator
    6980 * if no occurence is found.
     81 *
     82 * @param s1
     83 * @param s2
     84 * @return
    7085 */
    7186static char *strpbrk_null(const char *s1, const char *s2)
    7287{
    7388        while (!posix_strchr(s2, *s1)) {
    74                 ++ s1;
     89                ++s1;
    7590        }
    7691       
     
    8297 * @param dest
    8398 * @param src
    84  * @return dest
     99 * @return
    85100 */
    86101char *posix_strcpy(char *dest, const char *src)
     
    95110 * @param src
    96111 * @param n
    97  * @return dest
     112 * @return
    98113 */
    99114char *posix_strncpy(char *dest, const char *src, size_t n)
     
    114129        assert(src != NULL);
    115130
    116         for (size_t i = 0; ; ++ i) {
     131        for (size_t i = 0; ; ++i) {
    117132                dest[i] = src[i];
    118133               
     
    139154        assert(src != NULL);
    140155
    141         for (size_t i = 0; i < n; ++ i) {
     156        for (size_t i = 0; i < n; ++i) {
    142157                dest[i] = src[i];
    143158       
     
    147162                if (src[i] == '\0') {
    148163                        char *result = &dest[i];
    149                         for (++ i; i < n; ++ i) {
     164                        for (++i; i < n; ++i) {
    150165                                dest[i] = '\0';
    151166                        }
     
    161176 * @param dest
    162177 * @param src
    163  * @return dest
     178 * @return
    164179 */
    165180char *posix_strcat(char *dest, const char *src)
     
    177192 * @param src
    178193 * @param n
    179  * @return dest
     194 * @return
    180195 */
    181196char *posix_strncat(char *dest, const char *src, size_t n)
     
    198213 * @return Pointer to the first byte after c in dest if found, NULL otherwise.
    199214 */
    200 void *posix_memccpy(void *restrict dest, const void *restrict src, int c, size_t n)
     215void *posix_memccpy(void *dest, const void *src, int c, size_t n)
    201216{
    202217        assert(dest != NULL);
     
    206221        const unsigned char* bsrc = src;
    207222       
    208         for (size_t i = 0; i < n; ++ i) {
     223        for (size_t i = 0; i < n; ++i) {
    209224                bdest[i] = bsrc[i];
    210225       
     
    257272 * @param n
    258273 * @return Difference of the first pair of inequal bytes,
    259  *          or 0 if areas have the same content
     274 *     or 0 if areas have the same content
    260275 */
    261276int posix_memcmp(const void *mem1, const void *mem2, size_t n)
     
    267282        const unsigned char *s2 = mem2;
    268283       
    269         for (size_t i = 0; i < n; ++ i) {
     284        for (size_t i = 0; i < n; ++i) {
    270285                if (s1[i] != s2[i]) {
    271286                        return s2[i] - s1[i];
     
    302317        assert(s2 != NULL);
    303318
    304         for (size_t i = 0; i < n; ++ i) {
     319        for (size_t i = 0; i < n; ++i) {
    305320                if (s1[i] != s2[i]) {
    306321                        return s2[i] - s1[i];
     
    327342        const unsigned char *s = mem;
    328343       
    329         for (size_t i = 0; i < n; ++ i) {
     344        for (size_t i = 0; i < n; ++i) {
    330345                if (s[i] == (unsigned char) c) {
    331346                        return (void *) &s[i];
     
    346361       
    347362        /* special handling for the case that zero is searched for */
    348         if (c == '\0')
     363        if (c == '\0') {
    349364                return strzero(s);
     365        }
    350366       
    351367        /* otherwise just loop through the string until found */
    352368        while (*s != (char) c) {
    353                 if (*s == '\0')
     369                if (*s == '\0') {
    354370                        return NULL;
    355 
    356                 s ++;
     371                }
     372
     373                s++;
    357374        }
    358375       
     
    374391        /* the same as in strchr, except it loops in reverse direction */
    375392        while (*ptr != (char) c) {
    376                 if (ptr == s)
     393                if (ptr == s) {
    377394                        return NULL;
    378 
    379                 ptr ++;
     395                }
     396
     397                ptr++;
    380398        }
    381399
     
    425443
    426444        const char *ptr;
    427         for (ptr = s1; *ptr != '\0'; ++ ptr) {
    428                 if (!posix_strchr(s2, *ptr))
     445        for (ptr = s1; *ptr != '\0'; ++ptr) {
     446                if (!posix_strchr(s2, *ptr)) {
    429447                        break;
     448                }
    430449        }
    431450        return ptr - s1;
     
    444463
    445464        /* special case - needle is an empty string */
    446         if (*s2 == '\0')
     465        if (*s2 == '\0') {
    447466                return (char *) s1;
     467        }
    448468
    449469        // TODO: use faster algorithm
    450470        /* check for prefix from every position - quadratic complexity */
    451471        while (*s1 != '\0') {
    452                 if (begins_with(s1, s2))
     472                if (begins_with(s1, s2)) {
    453473                        return (char *) s1;
     474                }
    454475               
    455                 s1 ++;
     476                s1++;
    456477        }
    457478       
     
    489510        size_t len = posix_strlen(s2);
    490511
    491         if (n > len)
     512        if (n > len) {
    492513                posix_strcpy(s1, s2);
     514        }
    493515
    494516        return len;
     
    503525{
    504526        /* uses function from libc, we just have to negate errno
    505            (POSIX uses positive errorcodes, HelenOS has negative) */
    506         return (char *) str_error (-errnum);
     527         * (POSIX uses positive errorcodes, HelenOS has negative)
     528         */
     529        return (char *) str_error(-errnum);
    507530}
    508531
     
    510533 *
    511534 * @param errnum Error code
    512  * @param buf    Buffer to store a human readable string to
    513  * @param bufsz  Size of buffer pointed to by buf
     535 * @param buf Buffer to store a human readable string to
     536 * @param bufsz Size of buffer pointed to by buf
    514537 * @return
    515538 */
     
    552575        assert(s != NULL);
    553576       
    554         for (size_t sz = 0; sz < n; ++ sz) {
     577        for (size_t sz = 0; sz < n; ++sz) {
    555578               
    556579                if (s[sz] == '\0') {
  • uspace/lib/posix/string.h

    rf48b637 r0ffbed9  
    130130        #define strerror posix_strerror
    131131        #define strerror_r posix_strerror_r
    132         #define strsignal(i) ((char*) "SIGNonSense: There are no signals in HelenOS.")
     132        #define strsignal(i) ((char *) "SIGNonSense: There are no signals in HelenOS.")
    133133
    134134        #define strlen posix_strlen
  • uspace/lib/posix/strings.c

    rf48b637 r0ffbed9  
    11/*
    22 * Copyright (c) 2011 Jiri Zarevucky
     3 * Copyright (c) 2011 Petr Koupy
    34 * All rights reserved.
    45 *
     
    3334 */
    3435
    35 #define POSIX_INTERNAL
     36#define LIBPOSIX_INTERNAL
    3637
    37 #include "common.h"
     38#include "internal/common.h"
    3839#include "strings.h"
    3940#include "string.h"
     41#include "ctype.h"
    4042
     43/**
     44 *
     45 * @param i
     46 * @return
     47 */
    4148int posix_ffs(int i)
    4249{
     
    4552}
    4653
     54/**
     55 *
     56 * @param s1
     57 * @param s2
     58 * @return
     59 */
    4760int posix_strcasecmp(const char *s1, const char *s2)
    4861{
    49         // TODO
    50         not_implemented();
     62        return posix_strncasecmp(s1, s2, STR_NO_LIMIT);
    5163}
    5264
     65/**
     66 *
     67 * @param s1
     68 * @param s2
     69 * @param n
     70 * @return
     71 */
    5372int posix_strncasecmp(const char *s1, const char *s2, size_t n)
    5473{
    55         // TODO
    56         not_implemented();
     74        for (size_t i = 0; i < n; ++i) {
     75                int cmp = tolower(s1[i]) - tolower(s2[i]);
     76                if (cmp != 0) {
     77                        return cmp;
     78                }
     79               
     80                if (s1[i] == 0) {
     81                        return 0;
     82                }
     83        }
     84       
     85        return 0;
    5786}
    5887
     88/**
     89 *
     90 * @param mem1
     91 * @param mem2
     92 * @param n
     93 * @return
     94 */
    5995int posix_bcmp(const void *mem1, const void *mem2, size_t n)
    6096{
     
    6399}
    64100
     101/**
     102 *
     103 * @param dest
     104 * @param src
     105 * @param n
     106 */
    65107void posix_bcopy(const void *dest, void *src, size_t n)
    66108{
     
    69111}
    70112
     113/**
     114 *
     115 * @param mem
     116 * @param n
     117 */
    71118void posix_bzero(void *mem, size_t n)
    72119{
     
    75122}
    76123
     124/**
     125 *
     126 * @param s
     127 * @param c
     128 * @return
     129 */
    77130char *posix_index(const char *s, int c)
    78131{
     
    80133}
    81134
     135/**
     136 *
     137 * @param s
     138 * @param c
     139 * @return
     140 */
    82141char *posix_rindex(const char *s, int c)
    83142{
     
    87146/** @}
    88147 */
    89 
  • uspace/lib/posix/strings.h

    rf48b637 r0ffbed9  
    11/*
    22 * Copyright (c) 2011 Jiri Zarevucky
     3 * Copyright (c) 2011 Petr Koupy
    34 * All rights reserved.
    45 *
     
    3637#define POSIX_STRINGS_H_
    3738
    38 extern int posix_ffs(int);
     39/* Search Functions */
     40extern int posix_ffs(int i);
    3941
    40 extern int posix_strcasecmp(const char *, const char *);
    41 extern int posix_strncasecmp(const char *, const char *, size_t);
     42/* String/Array Comparison */
     43extern int posix_strcasecmp(const char *s1, const char *s2);
     44extern int posix_strncasecmp(const char *s1, const char *s2, size_t n);
    4245
    4346/* TODO: not implemented due to missing locale.h
     
    4750 */
    4851
    49 
    5052/* Legacy Functions */
    51 
    52 extern int posix_bcmp(const void *, const void *, size_t);
    53 extern void posix_bcopy(const void *, void *, size_t);
    54 extern void posix_bzero(void *, size_t);
    55 extern char *posix_index(const char *, int);
    56 extern char *posix_rindex(const char *, int);
     53extern int posix_bcmp(const void *mem1, const void *mem2, size_t n);
     54extern void posix_bcopy(const void *dest, void *src, size_t n);
     55extern void posix_bzero(void *mem, size_t n);
     56extern char *posix_index(const char *s, int c);
     57extern char *posix_rindex(const char *s, int c);
    5758
    5859#ifndef LIBPOSIX_INTERNAL
    5960        #define ffs posix_ffs
     61
    6062        #define strcasecmp posix_strcasecmp
    6163        #define strncasecmp posix_strncasecmp
    62        
     64
    6365        #define bcmp posix_bcmp
    6466        #define bcopy posix_bcopy
  • uspace/lib/posix/sys/stat.c

    rf48b637 r0ffbed9  
    11/*
    22 * Copyright (c) 2011 Jiri Zarevucky
     3 * Copyright (c) 2011 Petr Koupy
    34 * All rights reserved.
    45 *
     
    2728 */
    2829
     30/** @addtogroup libposix
     31 * @{
     32 */
     33/** @file
     34 */
     35
    2936#define LIBPOSIX_INTERNAL
    3037
    3138#include "stat.h"
     39#include "../internal/common.h"
    3240#include <mem.h>
    3341
    34 /* Convert HelenOS stat struct into POSIX stat struct (if possible)
     42/**
     43 * Convert HelenOS stat struct into POSIX stat struct (if possible)
     44 *
     45 * @param dest
     46 * @param src
    3547 */
    36 static void stat_to_posix (struct posix_stat *dest, struct stat *src)
     48static void stat_to_posix(struct posix_stat *dest, struct stat *src)
    3749{
    3850        memset(dest, 0, sizeof(struct posix_stat));
     
    4254        /* HelenOS doesn't support permissions, so we set them all */
    4355        dest->st_mode = S_IRWXU | S_IRWXG | S_IRWXO;
    44         if (src->is_file)
     56        if (src->is_file) {
    4557                dest->st_mode |= S_IFREG;
    46         if (src->is_directory)
     58        }
     59        if (src->is_directory) {
    4760                dest->st_mode |= S_IFDIR;
     61        }
    4862       
    4963        dest->st_nlink = src->lnkcnt;
     
    5165}
    5266
     67/**
     68 *
     69 * @param fd
     70 * @param st
     71 * @return
     72 */
    5373int posix_fstat(int fd, struct posix_stat *st)
    5474{
     
    6282}
    6383
     84/**
     85 *
     86 * @param path
     87 * @param st
     88 * @return
     89 */
     90int posix_lstat(const char *restrict path, struct posix_stat *restrict st)
     91{
     92        // TODO
     93        not_implemented();
     94}
     95
     96/**
     97 *
     98 * @param path
     99 * @param st
     100 * @return
     101 */
    64102int posix_stat(const char *path, struct posix_stat *st)
    65103{
     
    73111}
    74112
     113/**
     114 *
     115 * @param path
     116 * @param mode
     117 * @return
     118 */
     119int posix_chmod(const char *path, mode_t mode)
     120{
     121        // TODO
     122        not_implemented();
     123}
     124
     125/**
     126 *
     127 * @param mask
     128 * @return
     129 */
     130mode_t posix_umask(mode_t mask)
     131{
     132        // TODO
     133        not_implemented();
     134}
     135
     136/** @}
     137 */
  • uspace/lib/posix/sys/stat.h

    rf48b637 r0ffbed9  
    11/*
    22 * Copyright (c) 2011 Jiri Zarevucky
     3 * Copyright (c) 2011 Petr Koupy
    34 * All rights reserved.
    45 *
     
    2728 */
    2829
     30/** @addtogroup libposix
     31 * @{
     32 */
     33/** @file
     34 */
     35
    2936#ifndef POSIX_SYS_STAT_H_
    3037#define POSIX_SYS_STAT_H_
    3138
    3239#include "../libc/sys/stat.h"
    33 #include "time.h"
     40#include "types.h"
     41#include "../time.h"
     42#include <ipc/devmap.h>
     43#include <task.h>
     44
     45typedef devmap_handle_t posix_dev_t;
     46typedef task_id_t posix_pid_t;
    3447
    3548/* values are the same as on Linux */
     49
     50#undef S_IFMT
     51#undef S_IFSOCK
     52#undef S_IFLNK
     53#undef S_IFREG
     54#undef S_IFBLK
     55#undef S_IFDIR
     56#undef S_IFCHR
     57#undef S_IFIFO
    3658#define S_IFMT     0170000   /* all file types */
    3759#define S_IFSOCK   0140000   /* socket */
     
    4365#define S_IFIFO    0010000   /* FIFO */
    4466
     67#undef S_ISUID
     68#undef S_ISGID
     69#undef S_ISVTX
    4570#define S_ISUID    0004000   /* SUID */
    4671#define S_ISGID    0002000   /* SGID */
    4772#define S_ISVTX    0001000   /* sticky */
    4873
     74#undef S_IRWXU
     75#undef S_IRUSR
     76#undef S_IWUSR
     77#undef S_IXUSR
    4978#define S_IRWXU    00700     /* owner permissions */
    5079#define S_IRUSR    00400
     
    5281#define S_IXUSR    00100
    5382
     83#undef S_IRWXG
     84#undef S_IRGRP
     85#undef S_IWGRP
     86#undef S_IXGRP
    5487#define S_IRWXG    00070     /* group permissions */
    5588#define S_IRGRP    00040
     
    5790#define S_IXGRP    00010
    5891
     92#undef S_IRWXO
     93#undef S_IROTH
     94#undef S_IWOTH
     95#undef S_IXOTH
    5996#define S_IRWXO    00007     /* other permissions */
    6097#define S_IROTH    00004
     
    6299#define S_IXOTH    00001
    63100
     101#undef S_ISREG
     102#undef S_ISDIR
     103#undef S_ISCHR
     104#undef S_ISBLK
     105#undef S_ISFIFO
     106#undef S_ISLNK
     107#undef S_ISSOCK
    64108#define S_ISREG(m) ((m & S_IFREG) != 0)
    65109#define S_ISDIR(m) ((m & S_IFDIR) != 0)
     
    67111#define S_ISBLK(m) ((m & S_IFBLK) != 0)
    68112#define S_ISFIFO(m) ((m & S_IFIFO) != 0)
    69 #define S_ISLNK(m) ((m & S_IFLNK) != 0)   /* symbolic link? (Not in POSIX.1-1996.) */
     113#define S_ISLNK(m) ((m & S_IFLNK) != 0) /* symbolic link? (Not in POSIX.1-1996.) */
    70114#define S_ISSOCK(m) ((m & S_IFSOCK) != 0) /* socket? (Not in POSIX.1-1996.) */
    71 
    72 typedef devmap_handle_t dev_t;
    73 typedef unsigned int ino_t;
    74 typedef unsigned int nlink_t;
    75 typedef unsigned int uid_t;
    76 typedef unsigned int gid_t;
    77 typedef aoff64_t off_t;
    78 typedef unsigned int blksize_t;
    79 typedef unsigned int blkcnt_t;
    80115
    81116struct posix_stat {
    82117        struct stat sys_stat;
    83118
    84         dev_t     st_dev;     /* ID of device containing file */
    85         ino_t     st_ino;     /* inode number */
    86         mode_t    st_mode;    /* protection */
    87         nlink_t   st_nlink;   /* number of hard links */
    88         uid_t     st_uid;     /* user ID of owner */
    89         gid_t     st_gid;     /* group ID of owner */
    90         dev_t     st_rdev;    /* device ID (if special file) */
    91         off_t     st_size;    /* total size, in bytes */
    92         blksize_t st_blksize; /* blocksize for file system I/O */
    93         blkcnt_t  st_blocks;  /* number of 512B blocks allocated */
    94         time_t    st_atime;   /* time of last access */
    95         time_t    st_mtime;   /* time of last modification */
    96         time_t    st_ctime;   /* time of last status change */
     119        posix_dev_t     st_dev;     /* ID of device containing file */
     120        posix_ino_t     st_ino;     /* inode number */
     121        mode_t          st_mode;    /* protection */
     122        posix_nlink_t   st_nlink;   /* number of hard links */
     123        posix_uid_t     st_uid;     /* user ID of owner */
     124        posix_gid_t     st_gid;     /* group ID of owner */
     125        posix_dev_t     st_rdev;    /* device ID (if special file) */
     126        posix_off_t     st_size;    /* total size, in bytes */
     127        posix_blksize_t st_blksize; /* blocksize for file system I/O */
     128        posix_blkcnt_t  st_blocks;  /* number of 512B blocks allocated */
     129        time_t          st_atime;   /* time of last access */
     130        time_t          st_mtime;   /* time of last modification */
     131        time_t          st_ctime;   /* time of last status change */
    97132};
    98133
    99 extern int posix_fstat(int, struct posix_stat *);
    100 extern int posix_stat(const char *, struct posix_stat *);
     134extern int posix_fstat(int fd, struct posix_stat *st);
     135extern int posix_lstat(const char *restrict path, struct posix_stat *restrict st);
     136extern int posix_stat(const char *restrict path, struct posix_stat *restrict st);
     137extern int posix_chmod(const char *path, mode_t mode);
     138extern mode_t posix_umask(mode_t mask);
    101139
    102140#ifndef LIBPOSIX_INTERNAL
     141        #define dev_t posix_dev_t
     142        #define pid_t posix_pid_t
    103143        #define fstat posix_fstat
     144        #define lstat posix_lstat
    104145        #define stat posix_stat
     146        #define chmod posix_chmod
     147        #define umask posix_umask
    105148#endif
    106149
    107150#endif /* POSIX_SYS_STAT_H */
    108151
     152/** @}
     153 */
  • uspace/lib/posix/sys/types.h

    rf48b637 r0ffbed9  
    11/*
    22 * Copyright (c) 2011 Jiri Zarevucky
     3 * Copyright (c) 2011 Petr Koupy
    34 * All rights reserved.
    45 *
     
    2728 */
    2829
     30/** @addtogroup libposix
     31 * @{
     32 */
     33/** @file
     34 */
     35
    2936#ifndef POSIX_SYS_TYPES_H_
    3037#define POSIX_SYS_TYPES_H_
    3138
    3239#include "../libc/sys/types.h"
    33 #include <task.h>
    3440
    35 typedef task_id_t pid_t;
     41typedef unsigned int posix_ino_t;
     42typedef unsigned int posix_nlink_t;
     43typedef unsigned int posix_uid_t;
     44typedef unsigned int posix_gid_t;
     45typedef aoff64_t posix_off_t;
     46typedef unsigned int posix_blksize_t;
     47typedef unsigned int posix_blkcnt_t;
     48
     49#ifndef LIBPOSIX_INTERNAL
     50        #define ino_t posix_ino_t
     51        #define nlink_t posix_nlink_t
     52        #define uid_t posix_uid_t
     53        #define gid_t posix_gid_t
     54        #define off_t posix_off_t
     55        #define blksize_t posix_blksize_t
     56        #define blkcnt_t posix_blkcnt_t
     57#endif
    3658
    3759#endif /* POSIX_SYS_TYPES_H_ */
    3860
     61/** @}
     62 */
  • uspace/lib/posix/time.c

    rf48b637 r0ffbed9  
    3636#define LIBPOSIX_INTERNAL
    3737
     38#include "internal/common.h"
    3839#include "time.h"
    3940
     
    8384{
    8485        // TODO
    85         return 0;
     86        not_implemented();
    8687}
    8788
  • uspace/lib/posix/unistd.c

    rf48b637 r0ffbed9  
    11/*
    22 * Copyright (c) 2011 Jiri Zarevucky
     3 * Copyright (c) 2011 Petr Koupy
    34 * All rights reserved.
    45 *
     
    2728 */
    2829
     30/** @addtogroup libposix
     31 * @{
     32 */
     33/** @file
     34 */
     35
     36#define LIBPOSIX_INTERNAL
     37
     38#include "internal/common.h"
    2939#include "unistd.h"
    3040
    31 int isatty(int fd) {
    32         // TODO
    33         return 0;
     41/**
     42 * Dummy function. Always returns false, because there is no easy way to find
     43 * out under HelenOS.
     44 *
     45 * @param fd
     46 * @return Always false.
     47 */
     48int posix_isatty(int fd)
     49{
     50        return false;
    3451}
    3552
     53/**
     54 *
     55 * @return
     56 */
     57posix_uid_t posix_getuid(void)
     58{
     59        // TODO
     60        not_implemented();
     61}
     62
     63/**
     64 *
     65 * @return
     66 */
     67posix_gid_t posix_getgid(void)
     68{
     69        // TODO
     70        not_implemented();
     71}
     72
     73/**
     74 *
     75 * @param path
     76 * @param amode
     77 * @return
     78 */
     79int posix_access(const char *path, int amode)
     80{
     81        // TODO
     82        not_implemented();
     83}
     84
     85/**
     86 *
     87 * @param name
     88 * @return
     89 */
     90long posix_sysconf(int name)
     91{
     92        // TODO
     93        not_implemented();
     94}
     95
     96/** @}
     97 */
  • uspace/lib/posix/unistd.h

    rf48b637 r0ffbed9  
    11/*
    22 * Copyright (c) 2011 Jiri Zarevucky
     3 * Copyright (c) 2011 Petr Koupy
    34 * All rights reserved.
    45 *
     
    2627 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2728 */
    28  
     29
     30/** @addtogroup libposix
     31 * @{
     32 */
     33/** @file
     34 */
     35
    2936#ifndef POSIX_UNISTD_H_
    3037#define POSIX_UNISTD_H_
    3138
    3239#include "libc/unistd.h"
     40#include "sys/types.h"
    3341
    34 /* #include <getopt.h> */
     42/* Process Termination */
     43#define _exit exit
    3544
     45/* Option Arguments */
    3646extern char *optarg;
    3747extern int optind, opterr, optopt;
    3848extern int getopt(int, char * const [], const char *);
    3949
    40 extern int isatty(int fd);
     50/* Identifying Terminals */
     51extern int posix_isatty(int fd);
    4152
     53/* Process Identification */
    4254#define getpid task_get_id
     55extern posix_uid_t posix_getuid(void);
     56extern posix_gid_t posix_getgid(void);
    4357
     58/* Standard Streams */
     59#undef STDIN_FILENO
    4460#define STDIN_FILENO (fileno(stdin))
     61#undef STDOUT_FILENO
    4562#define STDOUT_FILENO (fileno(stdout))
     63#undef STDERR_FILENO
    4664#define STDERR_FILENO (fileno(stderr))
     65
     66/* File Accessibility */
     67#undef F_OK
     68#undef X_OK
     69#undef W_OK
     70#undef R_OK
     71#define F_OK 0 /* Test for existence. */
     72#define X_OK 1 /* Test for execute permission. */
     73#define W_OK 2 /* Test for write permission. */
     74#define R_OK 4 /* Test for read permission. */
     75extern int posix_access(const char *path, int amode);
     76
     77/* System Parameters */
     78enum {
     79        _SC_PHYS_PAGES,
     80        _SC_AVPHYS_PAGES,
     81        _SC_PAGESIZE,
     82        _SC_CLK_TCK
     83};
     84extern long posix_sysconf(int name);
     85
     86#ifndef LIBPOSIX_INTERNAL
     87        #define isatty posix_isatty
     88
     89        #define getuid posix_getuid
     90        #define getgid posix_getgid
     91
     92        #define access posix_access
     93
     94        #define sysconf posix_sysconf
     95#endif
    4796
    4897#endif /* POSIX_UNISTD_H_ */
    4998
     99/** @}
     100 */
Note: See TracChangeset for help on using the changeset viewer.