Im trying to create a preprocessor macro to allocate and free memory for matrix/vector of any data type. Here is what I have so far:
#ifndef H_ARRAY_H
#define H_ARRAY_H
#include "xmalloc.h"
#define make_vector(v,n) (v = xmalloc( (n) * sizeof *(v))
#define free_vector(v) do { free(v) ; v = NULL; } while(0)
#define make_matrx(a , m , n) do { \
size_t make_matrix_loop_counter; \
make_vector(a, (m) + 1); \
for ( make_matrix_loop_counter = 0; make_matrix_loop_counter < (m) ; make_matrix_loop_counter++) \
make_vector((a)[make_matrix_loop_counter], (n)); \
(a)[m] = NULL; \
} while (0)
#define free_matrix(a) do { \
if (a != NULL){ \
size_t make_matrix_loop_counter; \
for (make_matrix_loop_counter = 0 ; (a) [make_matrix_loop_counter] != NULL; make_matrix_loop_counter++) \
free_vector((a)[make_matrix_loop_counter]); \
free_vector(a); \
a != NULL; \
} \
} while (0)
But when I try to construct a matrix it spits out an error "implicit declaration of function ‘make_matrix’".
Any suggestions.
PS: xmalloc.h allocate space
Are you sure your MACRO name should read make_matrx instead of make_matrix?
You need to correct the macro name spelling. Otherwise, when you use make_matrix() in your code, it does not find a corresponding function.
Related
What I currently have
#define _CMPLT8 _mm_cmplt_epi8 // int8_t
#define _CMPLT32 _mm_cmplt_epi32 // int32_t
What I want (something similar to the following code)
#define _CMPLT(T) ( \
if(sizeof(T)==1) return _mm_cmplt_epi8 \
else if(sizeof(T)==4) return _mm_cmplt_epi32 \
else #error \
)
How could I this code?
If you want to return a string based on a type I'd go for generics:
#define _CMPLT(T) \
_Generic( (T), \
char: "1", \
int: "4", \
default: "0")
int main(void) {
char a;
int b;
printf("%s%s\n", _CMPLT(a), _CMPLT(b));
}
But I feel you want to call functions depending on arg type, so in that case:
#define _CMPLT(X, Y) _Generic((X), \
int8_t: _mm_cmplt_epi8(X, Y), \
int32_t: _mm_cmplt_epi32(X, Y) \
)
int main(void) {
int8_t a = 0, b = 1;
int32_t c = 2, d = 3;
printf("%d%d\n", _CMPLT(a, b), _CMPLT(c, d));
}
If you really need to use strings and sizeof, and can use compound statements, would this work for you?
#include <stdio.h>
#define _CMPLT(T) ({ \
switch(sizeof(T)) { \
case 1: "1"; \
case 4: "4"; \
}; \
"0"; \
})
int main(void) {
printf("%s%s\n",
_CMPLT(char), _CMPLT(int));
}
The following code is from better string library header.
While looking at the define macros, I notice that va_list, va_start, and va_end are all used inside the for loop.
Wonder why this is necessary?
By the way, I have looked into the function bvcformata which doesn't modify bstrmp_arglist.
#define bvformata(ret, b, fmt, lastarg) { \
bstring bstrtmp_b = (b); \
const char * bstrtmp_fmt = (fmt); \
int bstrtmp_r = BSTR_ERR, bstrtmp_sz = 16; \
for (;;) { \
va_list bstrtmp_arglist; \
va_start (bstrtmp_arglist, lastarg); \
bstrtmp_r = bvcformata (bstrtmp_b, bstrtmp_sz, bstrtmp_fmt, bstrtmp_arglist); \
va_end (bstrtmp_arglist); \
if (bstrtmp_r >= 0) { /* Everything went ok */ \
bstrtmp_r = BSTR_OK; \
break; \
} else if (-bstrtmp_r <= bstrtmp_sz) { /* A real error? */ \
bstrtmp_r = BSTR_ERR; \
break; \
} \
bstrtmp_sz = -bstrtmp_r; /* Doubled or target size */ \
} \
ret = bstrtmp_r; \
}
#endif
Could the va_list, va_start, and va_end be "moved" out of the for loop? I am still a beginner in C. Just wondering why they have to be used inside the for loop?
#define bvformata(ret, b, fmt, lastarg) { \
bstring bstrtmp_b = (b); \
const char * bstrtmp_fmt = (fmt); \
int bstrtmp_r = BSTR_ERR, bstrtmp_sz = 16; \
va_list bstrtmp_arglist; \ <--------*****
va_start (bstrtmp_arglist, lastarg); \ <--------*****
for (;;) { \
bstrtmp_r = bvcformata (bstrtmp_b, bstrtmp_sz, bstrtmp_fmt, bstrtmp_arglist); \
if (bstrtmp_r >= 0) { /* Everything went ok */ \
bstrtmp_r = BSTR_OK; \
break; \
} else if (-bstrtmp_r <= bstrtmp_sz) { /* A real error? */ \
bstrtmp_r = BSTR_ERR; \
break; \
} \
bstrtmp_sz = -bstrtmp_r; /* Doubled or target size */ \
} \
va_end (bstrtmp_arglist); \ <--------*****
ret = bstrtmp_r; \
}
#endif
You can move the va_list declaration outside the loop. But va_start and va_end have to stay in the loop, so that each call to bvcformata() will process the variable arguments from the beginning again.
#define bvformata(ret, b, fmt, lastarg) { \
bstring bstrtmp_b = (b); \
const char * bstrtmp_fmt = (fmt); \
int bstrtmp_r = BSTR_ERR, bstrtmp_sz = 16; \
va_list bstrtmp_arglist; \
for (;;) { \
va_start (bstrtmp_arglist, lastarg); \
bstrtmp_r = bvcformata (bstrtmp_b, bstrtmp_sz, bstrtmp_fmt, bstrtmp_arglist); \
va_end (bstrtmp_arglist); \
if (bstrtmp_r >= 0) { /* Everything went ok */ \
bstrtmp_r = BSTR_OK; \
break; \
} else if (-bstrtmp_r <= bstrtmp_sz) { /* A real error? */ \
bstrtmp_r = BSTR_ERR; \
break; \
} \
bstrtmp_sz = -bstrtmp_r; /* Doubled or target size */ \
} \
ret = bstrtmp_r; \
}
#endif
Never mind silly me. I just notice that there are "break"s within the for loop. By "moving" the va_list and va_end out will create a memory leak.
I have two programs that use the same tricks and features, and only one of them compiles.
A) This one compiles, and also works as expected:
#include <errno.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
/*
* int mallocs(T **restrict p, ptrdiff_t nmemb);
*/
#define mallocs(ptr, nmemb) ( \
{ \
ptrdiff_t nmemb_ = (nmemb); \
__auto_type ptr_ = (ptr); \
int err_; \
\
err_ = 0; \
if (ptr_ == NULL) { \
errno = EINVAL; \
err_ = EINVAL; \
goto ret_; \
} \
if (nmemb_ < 0) { \
*ptr_ = NULL; \
errno = EOVERFLOW; \
err_ = -EOVERFLOW; \
goto ret_; \
} \
if (nmemb_ > (PTRDIFF_MAX / (ptrdiff_t)sizeof(**ptr_))) { \
*ptr_ = NULL; \
errno = EOVERFLOW; \
err_ = EOVERFLOW; \
goto ret_; \
} \
\
*ptr_ = malloc(sizeof(**ptr_) * nmemb_); \
if (!(*ptr_)) \
err_ = ENOMEM; \
ret_: \
err_; \
} \
)
int main(void)
{
int *b1;
int **p;
int c = getchar();
p = &b1;
if (c == 'a')
p = 0;
printf("%c\n", c);
if (mallocs(p, 47))
goto err;
b1[4] = 52;
printf("Hi: %i\n", b1[4]);
free(b1);
return 0;
err:
perror(NULL);
exit(EXIT_FAILURE);
}
B) This one doesn't even compile (error is shown below):
#include <assert.h>
#include <errno.h>
#include <stdio.h>
#define alx_same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
#define alx_static_assert_array(a) do \
{ \
static_assert(!alx_same_type((a), &(a)[0]), "Not an array!"); \
} while (0)
/*
* int alx_sbprintf(char buff[restrict], int *restrict written,
* const char *restrict format, ...);
*/
#define alx_sbprintf(buff, written, format, ...) ( \
{ \
__auto_type w_ = (written); \
int len_; \
int err_; \
\
alx_static_assert_array(buff); \
err_ = 0; \
\
len_ = snprintf(buff, sizeof(buff), format, ##__VA_ARGS__); \
if (w_ != NULL) \
*w_ = len_; \
\
if (len_ < 0) { \
err_ = -errno; \
goto ret_; \
} \
if ((unsigned)len_ >= sizeof(buff)) { \
if (w_ != NULL) \
*w_ = sizeof(buff) - 1; \
errno = ENOMEM; \
err_ = ENOMEM; \
goto ret_; \
} \
ret_: \
err_; \
} \
)
int main(void)
{
char b1[10];
char b2[BUFSIZ];
int w1;
int *w2 = NULL;
if (alx_sbprintf(b1, &w1, "testttt%i", 12))
printf("Error 1.1\n");
printf("b1: %s; w1 = %i\n", b1, w1);
if (alx_sbprintf(b2, w2, "test%s", "testtt"))
printf("Error 2.1\n");
printf("b2: %s; w2 = %p\n", b2, w2);
return 0;
}
Error:
$ gcc -std=gnu17 -Wall -Wextra -Werror main.c
main.c: In function ‘main’:
main.c:39:3: error: jump into statement expression
goto ret_; \
^~~~
main.c:70:6: note: in expansion of macro ‘alx_sbprintf’
if (alx_sbprintf(b2, w2, "test%s", "testtt"))
^~~~~~~~~~~~
main.c:48:1: note: label ‘ret_’ defined here
ret_: \
^~~~
main.c:66:6: note: in expansion of macro ‘alx_sbprintf’
if (alx_sbprintf(b1, &w1, "testttt%i", 12))
^~~~~~~~~~~~
main.c:46:3: error: jump into statement expression
goto ret_; \
^~~~
main.c:70:6: note: in expansion of macro ‘alx_sbprintf’
if (alx_sbprintf(b2, w2, "test%s", "testtt"))
^~~~~~~~~~~~
main.c:48:1: note: label ‘ret_’ defined here
ret_: \
^~~~
main.c:66:6: note: in expansion of macro ‘alx_sbprintf’
if (alx_sbprintf(b1, &w1, "testttt%i", 12))
^~~~~~~~~~~~
main.c:48:1: error: duplicate label ‘ret_’
ret_: \
^~~~
main.c:70:6: note: in expansion of macro ‘alx_sbprintf’
if (alx_sbprintf(b2, w2, "test%s", "testtt"))
^~~~~~~~~~~~
main.c:48:1: note: previous definition of ‘ret_’ was here
ret_: \
^~~~
main.c:66:6: note: in expansion of macro ‘alx_sbprintf’
if (alx_sbprintf(b1, &w1, "testttt%i", 12))
^~~~~~~~~~~~
Why does only one of them throw that error?
GNU C does forbid jumping into a statement expression, but your main problem is that expanding the macro results in the ret_ label being duplicated.
You'll want to combine this statement expression with the __label__ extension for declaring scope-local labels:
#include <assert.h>
#include <errno.h>
#include <stdio.h>
#define alx_same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
#define alx_static_assert_array(a) do \
{ \
static_assert(!alx_same_type((a), &(a)[0]), "Not an array!"); \
} while (0)
/*
* int alx_sbprintf(char buff[restrict], int *restrict written,
* const char *restrict format, ...);
*/
#define alx_sbprintf(buff, written, format, ...) ( \
{ \
__label__ ret_; \
__auto_type w_ = (written); \
int len_; \
int err_; \
\
alx_static_assert_array(buff); \
err_ = 0; \
\
len_ = snprintf(buff, sizeof(buff), format, ##__VA_ARGS__); \
if (w_ != NULL) \
*w_ = len_; \
\
if (len_ < 0) { \
err_ = -errno; \
goto ret_; \
} \
if ((unsigned)len_ >= sizeof(buff)) { \
if (w_ != NULL) \
*w_ = sizeof(buff) - 1; \
errno = ENOMEM; \
err_ = ENOMEM; \
goto ret_; \
} \
ret_: \
err_; \
} \
)
int main(void)
{
char b1[10];
char b2[BUFSIZ];
int w1;
int *w2 = NULL;
if (alx_sbprintf(b1, &w1, "testttt%i", 12))
printf("Error 1.1\n");
printf("b1: %s; w1 = %i\n", b1, w1);
if (alx_sbprintf(b2, w2, "test%s", "testtt"))
printf("Error 2.1\n");
printf("b2: %s; w2 = %p\n", b2, w2);
return 0;
}
(I've only copied the rest of the code but the addition of __label__ ret_; makes the code compile.)
In example B, you invoke the alx_sbprintf macro twice. This causes the ret_ label to be defined twice, leading to the "duplicate label" error.
The labels aren't scoped to the statement expression, they're scoped to the function.
I'm not sure why the same "jump into statement expression" error isn't raised in your first example though.
Theres no reason to use GCC expression statements like this, when a function will work just fine. (Possibly static inline if you want to put it in a header file.)
I have the following structure (simplified):
struct error_t{
const char *file;
const char *error_desc;
};
I wrote a macro to create the structure
#define ERROR_SET(error_desc) \
{ \
struct error_t tmp = {.error_desc = error_desc, .file = __FILE__}; \
struct error_t *ptr = malloc(sizeof(*ptr)); \
memcpy(ptr, &tmp, sizeof(tmp)); \
*error_ptr = ptr; \
}
The problem is that at the line
struct error_t tmp = {.error_desc = error_desc, .file = __FILE__}
both error_descs .error_desc = error_desc are replaced which is not what I wanted. The only solution I can see is to rename the macro function parameter from error_desc to _error_desc, but maybe there is a better way. Maybe we can sort of "escape" the error_desc to be substituted in the .error_desc?
Just do not use the same name for the parameter and the struct member
You can have a different MACRO that the preprocessor would replace as error_desc.
#define ERROR_DESC error_desc
Then you can define ERROR_SET like this:
#define ERROR_SET(error_desc) \
{ \
struct error_t tmp = {.ERROR_DESC = error_desc, .file = __FILE__}; \
struct error_t *ptr = malloc(sizeof(*ptr)); \
memcpy(ptr, &tmp, sizeof(tmp)); \
*error_ptr = ptr; \
}
This works because the substitution is done only once.
You can "deceive" the preprocessor with something like
#define CONCAT(a, b) a##b
#define ERROR_SET(error_desc) \
{ \
struct error_t tmp = { .CONCAT(error,_desc) = error_desc, .file = __FILE__ }; \
...\
}
but it is just not worth it. Just rename the parameter. And develop a convention for parameter naming that would help you to avoid such naming conflicts in the future.
On the second thought, the extra CONCAT macro is not even necessary. This will achieve the same objective
#define ERROR_SET(error_desc) \
{ \
struct error_t tmp = { .error##_desc = error_desc, .file = __FILE__ }; \
...\
}
I am trying to define a macro -
#define macro1(arg1) \
do{ \
int _state = 0; \
if (arg1 && arg1->member_) \
_state = arg1->member_->state_; \
printf("%d", _state); \
} while(0)
A *a = new A():
macro1(a); // Works
macro1(NULL); // Error
The specific error I see is -
"error: base operand of ‘->’ is not a pointer"
Aren't we allowed to pass NULL as an argument to macros?
Macro expansion is just text replacement, so when you passed NULL, it will expand to NULL->member, clearly it is an error. One way is to use a temporary variable for that:
#define macro1(arg1) \
do{ \
A* p = (arg1);
int _state = 0; \
if (p && p->member_) \
_state = p->member_->state_; \
printf("%d", _state); \
} while(0)
A *a = new A():
macro1(a);
macro1(NULL);
This way both cases will work.
You have to understand what's a macro in order to understand your mistake. Except for the compiler, there's an animal called pre-compiler. It replaces all the macros' references by the actual code defined for this macro. So this code:
#define macro1(arg1) \
do{ \
int _state = 0; \
if (arg1 && arg1->member_) \
_state = arg1->member_->state_; \
printf("%d", _state); \
} while(0)
A *a = new A():
macro1(a); // Works
macro1(NULL); // Error
will be replaced with:
A *a = new A():
do{
int _state = 0;
if (a && a->member_)
_state = a->member_->state_;
printf("%d", _state);
} while(0)
do{
int _state = 0;
if (NULL && NULL->member_)
_state = NULL->member_->state_;
printf("%d", _state);
} while(0)
THIS code will be compiled. And now you can see for yourself what's the root cause of the compilation error.
Macros are just a text replacement.
for example, if you have
#define mac(x) x/x
that would work for must numbers but not for 0, because it will be replaced with 0/0 which is not defined.
in your case if you pass NULL it will be replaced with:
do{ \
int _state = 0; \
if (NULL && NULL->member_) \
_state = NULL ->member_->state_; \
printf("%d", _state); \
} while(0)
so what is the meaning of NULL->member_ in this case. No sense, hence it fails.
consider using a regular function, or two macros one for regular pointers and one for NULL pointers, and make your code as this:
if (ptr)
macro1(ptr);
else
macro2;
Small adjust let the pre-compiler know the type size + a forward declaration and it'll work:
#define macro1(arg1) \
do{ \
int _state = 0; \
if ((arg1) && ((A*)arg1)->member_) \
_state = ((A*)arg1)->member_->state_; \
printf("%d", _state); \
} while(0)
Complete code:
#include <stdio.h>
class A;
#define macro1(arg1) \
do{ \
int _state = 0; \
if ((arg1) && ((A*)arg1)->member_) \
_state = ((A*)arg1)->member_->state_; \
printf("%d", _state); \
} while(0)
struct member{
int state_;
};
class A {
public:
member* member_;
};
int main(int n, char** arg) {
A* a = new A();
a->member_ = new member();
a->member_->state_ = 1;
macro1(a);
macro1(NULL);
return 0;
}
The more fundamental problem is that NULL is not a pointer, it is a macro for 0.
Hence when you pass in NULL, it is equivalent to passing in 0, which of course is an error.
As other answers have mentioned, giving the argument an explicit cast will fix it
(A*)arg1
As a side note, you should be using nullptr in C++ for a null pointer.
EDIT: As #AjayBrahmakshatriya pointed out, NULL can be defined as (void*)0 (in C only) which will be a pointer, but the argument still holds true, NULL is not a pointer of your type.
EDIT2: Apparently in C++11 and later, NULL can be defined as nullptr