stdlib.c

Go to the documentation of this file.

 
#include "libc.h"
#include <lely/libc/stdlib.h>
 
#if !(__STDC_VERSION__ >= 201112L)
 
#ifndef LELY_HAVE_POSIX_MEMALIGN
#if _POSIX_C_SOURCE >= 200112L
#define LELY_HAVE_POSIX_MEMALIGN 1
#if defined(__NEWLIB__) && !defined(__rtems__)
#undef LELY_HAVE_POSIX_MEMALIGN
#endif
#endif
#endif
 
#if _WIN32
#include <malloc.h>
#elif defined(LELY_HAVE_POSIX_MEMALIGN)
#include <errno.h>
#else
#include <stdint.h>
#endif
 
void *
aligned_alloc(size_t alignment, size_t size)
{
#if _WIN32
        if (!size)
                return NULL;
        return _aligned_malloc(size, alignment);
#elif LELY_HAVE_POSIX_MEMALIGN
        void *ptr = NULL;
        int errnum = posix_memalign(&ptr, alignment, size);
        if (errnum) {
                errno = errnum;
                return NULL;
        }
        return ptr;
        // clang-format off
#else // !_WIN32 && !LELY_HAVE_POSIX_MEMALIGN
        // Check if the alignment is a multiple if sizeof(void *) that is also a
        // power of two
        if ((alignment & (alignment - 1)) || alignment < sizeof(void *))
                return NULL;
        // clang-format on
        if (!size)
                return NULL;
 
        // malloc() is guaranteed to return a pointer aligned to at at least
        // sizeof(void *), the minimum value of 'alignment'. We therefore need
        // at most 'alignment' extra bytes.
        void *ptr = malloc(size + alignment);
        if (!ptr)
                return NULL;
        // Align the pointer.
        void *aligned_ptr = (void *)(((uintptr_t)(char *)ptr + alignment - 1)
                        & ~(uintptr_t)(alignment - 1));
        // Store the pointer obtained from malloc() right before the memory
        // region we return to the user.
        ((void **)aligned_ptr)[-1] = ptr;
 
        return aligned_ptr;
#endif // !_WIN32 && !LELY_HAVE_POSIX_MEMALIGN
}
 
#ifndef __USE_ISOC11
 
void
aligned_free(void *ptr)
{
#if _WIN32
        _aligned_free(ptr);
#elif LELY_HAVE_POSIX_MEMALIGN
        free(ptr);
#else
        if (ptr)
                free(((void **)ptr)[-1]);
#endif
}
 
#endif // !__USE_ISOC11
 
#endif // !(__STDC_VERSION__ >= 201112L)
 
#if _WIN32
 
#include <lely/libc/stdio.h>
 
#include <errno.h>
 
int
setenv(const char *envname, const char *envval, int overwrite)
{
        if (!envname) {
                errno = EINVAL;
                return -1;
        }
 
        if (!overwrite && getenv(envname))
                return 0;
 
        for (const char *cp = envname; *cp; cp++) {
                if (*cp == '=') {
                        errno = EINVAL;
                        return -1;
                }
        }
 
        char *string = NULL;
        if (asprintf(&string, "%s=%s", envname, envval) < 0)
                return -1;
 
        if (_putenv(string)) {
                int errsv = errno;
                free(string);
                errno = errsv;
                return -1;
        }
 
        free(string);
        return 0;
}
 
#endif // _WIN32