Macro to allocate a static array in compile time

Is there a way to allocate a static array in compile time ?

Example:

    typedef struct Node
    {
    	struct Node* prev;
    	struct Node* next;  		       
    	bool allocated;     
    	void* object;
    }node_t;

    #define ALLOC( size ) { node_t vec[size]; return &vec[0] }     

    #define list_const_func_pointers(max_list_size)  \
    {                                                \
        .maximum_list_size = max_list_size,          \
	    .vectorLL = ALLOC( max_list_size ),          \
    	.init = init_linked_list,                    \
	    .my_st_malloc = my_static_malloc             \
    }
   
    struct static_doublyll_t
    {
        node_t* head;
        node_t* last;
        int32_t list_size;  // "actual list size"
    	const uint32_t maximum_list_size;  // Tamanho do array de node_t alocado estaticamente.    
    	node_t* vectorLL;  // Aponta para uma array de node_t alocado estaticamente.
    	
    	void (*const init)(static_doublyll_t*);
    		
    	node_t* (*const my_st_malloc)(static_doublyll_t* l);
    	
    	static_doublyll_t* this_pointer;  // unnecessary because "recursion problem".	
    };

// Driver code:

    #define list_size 20
    
    static static_doublyll_t list = list_const_func_pointers(list_size); // init the const "variables".

Notes:

• I need that the compiler return unique memory blocks (statically allocated at compile time) on each macro call.

• This macro in the above example is what I need to work:

    #define ALLOC( size ) { node_t vec[size]; return &vec[0] }"
  

I would suggest something more simple.

    typedef struct Node
    {
        struct Node* prev;
        struct Node* next;                 
        bool allocated;     
        void* object;
    }node_t;


    #define DECLARE(name, max_list_size)            \
    static node_t node_t##name[max_list_size];     \
    struct static_doublyll_t name =                 \
    {                                               \
        .maximum_list_size = max_list_size,         \
        .vectorLL = node_t##name,                  \
    }
   
    struct static_doublyll_t
    {
        node_t* head;
        node_t* last;
        int32_t list_size;  // "actual list size"
        const uint32_t maximum_list_size;  // Tamanho do array de node_t alocado estaticamente.    
        node_t* vectorLL;  // Aponta para uma array de node_t alocado estaticamente.
    };

// Driver code:

    #define list_size 20
    
    DECLARE(list, list_size); 

> I need that the compiler return unique memory blocks(statically allocated at compile time) on each macro call.

Macros are not "called" in the same sense as functions, and they do not "return" anything. The compiler expands macro invocations at compile time, and compiles the result as C code, in the context of the surrounding C code.

You are using the macro in a context where it needs to expand to an expression of array or pointer type. Your best bet for that would be to use a compound literal:

#define ALLOC(size) ( (node_t []) { [size - 1] = {0} } )

That will produce an array with static storage duration only at file scope (that is, outside any function). It's unclear from the example code whether that would serve your purpose. I observe, however, that the only other context where what you describe could make sense would be in the initializer of a local object with static storage duration, and if that's what you have then you could consider just moving that out of its function.

Note well that what you describe does not make any sense at all for something that needs to provide a separate array on each call to some function, nor where the size parameter is not a compile-time constant at each invocation. Those kinds of things generally demand dynamic allocation.