Revisions to Macro for allocation in C

Rename: mallocarray()

Source Link

edited Aug 11, 2019 at 23:42

2k
9
23

#include <errno.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>


#define mallocs(ptr, nmemb) (                               \
{                                                           \
        __auto_type     ptr_    = (ptr);                    \
                                                            \
        *ptr_   = mallocs__mallocarray((nmemb), sizeof(**ptr_));       \
                                                            \
        !(*ptr_);                                           \
}                                                           \
)


inline
void    *mallocs__*mallocarray(ptrdiff_t nmemb, size_t size);


inline
void    *mallocs__*mallocarray(ptrdiff_t nmemb, size_t size)
{

    if (nmemb < 0)
        goto ovf;
    if (nmemb > (PTRDIFF_MAX / (ptrdiff_t)size))
        goto ovf;

    return  malloc(size * nmemb);
ovf:
    errno   = EOVERFLOW;
    return  NULL;
}

I named mallocarray() after the BSD extension reallocarray()

#include <errno.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>


#define mallocs(ptr, nmemb) (                               \
{                                                           \
        __auto_type     ptr_    = (ptr);                    \
                                                            \
        *ptr_   = mallocs__((nmemb), sizeof(**ptr_));       \
                                                            \
        !(*ptr_);                                           \
}                                                           \
)


inline
void    *mallocs__(ptrdiff_t nmemb, size_t size);


inline
void    *mallocs__(ptrdiff_t nmemb, size_t size)
{

    if (nmemb < 0)
        goto ovf;
    if (nmemb > (PTRDIFF_MAX / (ptrdiff_t)size))
        goto ovf;

    return  malloc(size * nmemb);
ovf:
    errno   = EOVERFLOW;
    return  NULL;
}

#include <errno.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>


#define mallocs(ptr, nmemb) (                               \
{                                                           \
        __auto_type     ptr_    = (ptr);                    \
                                                            \
        *ptr_   = mallocarray((nmemb), sizeof(**ptr_));     \
                                                            \
        !(*ptr_);                                           \
}                                                           \
)


inline
void    *mallocarray(ptrdiff_t nmemb, size_t size);


inline
void    *mallocarray(ptrdiff_t nmemb, size_t size)
{

    if (nmemb < 0)
        goto ovf;
    if (nmemb > (PTRDIFF_MAX / (ptrdiff_t)size))
        goto ovf;

    return  malloc(size * nmemb);
ovf:
    errno   = EOVERFLOW;
    return  NULL;
}

I named mallocarray() after the BSD extension reallocarray()

optimize; use C99 inline

Source Link

edited Jul 8, 2019 at 14:42

alx - recommends codidact

2k
9
23

After finding that the code above can only be called once in a function, I improved it making use of aan static inline and __label__. Now there is the possibility to call the function or the macro, depending on your preferences (both can be called multiple times):

#include <errno.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>


#define mallocs(ptr, nmemb) (                               \
{                                                           \
        __label__   ret_;                                   \
    __auto_type    __auto_type ptr_    = (ptr);                        \
        int         err_;                                   \
                                                            \
        err_    = 0;                                        \
        if (ptr_ == NULL) {                                 \
                errno   = EINVAL;                           \
                err_    = EINVAL;                           \
                goto ret_;                                  \
        }                                                   \
                                                            \
        *ptr_   = mallocs__((nmemb), sizeof(**ptr_));       \
        if (!(*ptr_))                                       \
                err_    = errno;                            \
ret_:                                                       \
        err_;    !(*ptr_);                                           \
}                                                           \
)


static inline    
void    *mallocs__(ptrdiff_t nmemb, size_t size);


static inline    
void    *mallocs__(ptrdiff_t nmemb, size_t size)
{

    if (nmemb < 0)
        goto ovf;
    if (nmemb > (PTRDIFF_MAX / (ptrdiff_t)size))
        goto ovf;

    return  malloc(size * nmemb);
ovf:
    errno   = EOVERFLOW;
    return  NULL;
}

After finding that the code above can only be called once in a function, I improved it making use of a static inline and __label__. Now there is the possibility to call the function or the macro, depending on your preferences (both can be called multiple times):

#include <errno.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>


#define mallocs(ptr, nmemb) (                               \
{                                                           \
        __label__   ret_;                                   \
        __auto_type ptr_    = (ptr);                        \
        int         err_;                                   \
                                                            \
        err_    = 0;                                        \
        if (ptr_ == NULL) {                                 \
                errno   = EINVAL;                           \
                err_    = EINVAL;                           \
                goto ret_;                                  \
        }                                                   \
                                                            \
        *ptr_   = mallocs__((nmemb), sizeof(**ptr_));       \
        if (!(*ptr_))                                       \
                err_    = errno;                            \
ret_:                                                       \
        err_;                                               \
}                                                           \
)


static inline   void    *mallocs__(ptrdiff_t nmemb, size_t size);


static inline   void    *mallocs__(ptrdiff_t nmemb, size_t size)
{

    if (nmemb < 0)
        goto ovf;
    if (nmemb > (PTRDIFF_MAX / (ptrdiff_t)size))
        goto ovf;

    return  malloc(size * nmemb);
ovf:
    errno   = EOVERFLOW;
    return  NULL;
}

After finding that the code above can only be called once in a function, I improved it making use of an inline. Now there is the possibility to call the function or the macro, depending on your preferences (both can be called multiple times):

#include <errno.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>


#define mallocs(ptr, nmemb) (                               \
{                                                           \
        __auto_type     ptr_    = (ptr);                    \
                                                            \
        *ptr_   = mallocs__((nmemb), sizeof(**ptr_));       \
                                                            \
        !(*ptr_);                                           \
}                                                           \
)


inline 
void    *mallocs__(ptrdiff_t nmemb, size_t size);


inline 
void    *mallocs__(ptrdiff_t nmemb, size_t size)
{

    if (nmemb < 0)
        goto ovf;
    if (nmemb > (PTRDIFF_MAX / (ptrdiff_t)size))
        goto ovf;

    return  malloc(size * nmemb);
ovf:
    errno   = EOVERFLOW;
    return  NULL;
}

rename

Source Link

edited Jun 30, 2019 at 22:49

alx - recommends codidact

2k
9
23

#include <errno.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>


#define mallocs__mallocs(ptr, nmemb) (  (                             \
{                                                           \
        __label__   ret_;                                   \
        __auto_type ptr_    = (ptr);                        \
        int         err_;                                   \
                                                            \
        err_    = 0;                                        \
        if (ptr_ == NULL) {                                 \
                errno   = EINVAL;                           \
                err_    = EINVAL;                           \
                goto ret_;                                  \
        }                                                   \
                                                            \
        *ptr_   = mallocsmallocs__((nmemb), sizeof(**ptr_));         \
        if (!(*ptr_))                                       \
                err_    = errno;                            \
ret_:                                                       \
        err_;                                               \
}                                                           \
)


static inline   void    *mallocs*mallocs__(ptrdiff_t nmemb, size_t size);


static inline   void    *mallocs*mallocs__(ptrdiff_t nmemb, size_t size)
{

    if (nmemb < 0)
        goto neg;ovf;
    if (nmemb > (PTRDIFF_MAX / (ptrdiff_t)size))
        goto ovf;

    return  malloc(size * nmemb);
neg:
ovf:
    errno   = EOVERFLOW;
    return  NULL;
}

#include <errno.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>


#define mallocs__(ptr, nmemb)   (                           \
{                                                           \
        __label__   ret_;                                   \
        __auto_type ptr_    = (ptr);                        \
        int         err_;                                   \
                                                            \
        err_    = 0;                                        \
        if (ptr_ == NULL) {                                 \
                errno   = EINVAL;                           \
                err_    = EINVAL;                           \
                goto ret_;                                  \
        }                                                   \
                                                            \
        *ptr_   = mallocs((nmemb), sizeof(**ptr_));         \
        if (!(*ptr_))                                       \
                err_    = errno;                            \
ret_:                                                       \
        err_;                                               \
}                                                           \
)


static inline   void    *mallocs(ptrdiff_t nmemb, size_t size);


static inline   void    *mallocs(ptrdiff_t nmemb, size_t size)
{

    if (nmemb < 0)
        goto neg;
    if (nmemb > (PTRDIFF_MAX / (ptrdiff_t)size))
        goto ovf;

    return  malloc(size * nmemb);
neg:
ovf:
    errno   = EOVERFLOW;
    return  NULL;
}

#include <errno.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>


#define mallocs(ptr, nmemb) (                               \
{                                                           \
        __label__   ret_;                                   \
        __auto_type ptr_    = (ptr);                        \
        int         err_;                                   \
                                                            \
        err_    = 0;                                        \
        if (ptr_ == NULL) {                                 \
                errno   = EINVAL;                           \
                err_    = EINVAL;                           \
                goto ret_;                                  \
        }                                                   \
                                                            \
        *ptr_   = mallocs__((nmemb), sizeof(**ptr_));       \
        if (!(*ptr_))                                       \
                err_    = errno;                            \
ret_:                                                       \
        err_;                                               \
}                                                           \
)


static inline   void    *mallocs__(ptrdiff_t nmemb, size_t size);


static inline   void    *mallocs__(ptrdiff_t nmemb, size_t size)
{

    if (nmemb < 0)
        goto ovf;
    if (nmemb > (PTRDIFF_MAX / (ptrdiff_t)size))
        goto ovf;

    return  malloc(size * nmemb);
ovf:
    errno   = EOVERFLOW;
    return  NULL;
}

move line

Source Link

edited Jun 30, 2019 at 19:20

alx - recommends codidact

2k
9
23

Loading

added 16 characters in body

Source Link

edited Jun 30, 2019 at 16:13

alx - recommends codidact

2k
9
23

Loading

explain

Source Link

edited Jun 30, 2019 at 15:31

alx - recommends codidact

2k
9
23

Loading

__

Source Link

edited Jun 30, 2019 at 15:24

alx - recommends codidact

2k
9
23

Loading

Fix bug; use static inline

Source Link

edited Jun 30, 2019 at 14:53

alx - recommends codidact

2k
9
23

Loading

Rollback to Revision 2

Source Link

edited Jun 29, 2019 at 11:54

alx - recommends codidact

2k
9
23

Loading

added 101 characters in body; added 6 characters in body

Source Link

edited Jun 29, 2019 at 11:52

alx - recommends codidact

2k
9
23

Loading

Fix bug: sizeof; deleted 1 character in body; added 13 characters in body

Source Link

edited Jun 29, 2019 at 0:34

alx - recommends codidact

2k
9
23

Loading

Source Link

answered Jun 29, 2019 at 0:14

alx - recommends codidact

2k
9
23

Loading

Stack Exchange Network

Return to Answer