c array wrapper struct no malloc allowed - c

Question

(btw I'm not allowed to malloc in this, I'm writing in c for c99)
I'm trying to create a wrapper struct in c for arrays to keep things tidy so I don't need to keep passing the array pointer and the length around, and can just use a struct:
#define MAX_LEN 64
typedef struct {
uint8_t data[MAX_LEN];
size_t len;
} byteArray_t;
Which is fine if MAX_LEN is known, but is there a way to make the length variable although known at compile time, so that for example I could have something like:
typedef struct {
byteArray_t tag;
byteArray_t length;
byteArray_t value;
} tlv_t;
In which the array corresponding to tag would have size MAX_TAG_LEN and so on for the others - so I'd need to tell the compiler somehow that that was the case...
Anyone got any ideas? Thanks!
Edit
Alright, sorry for the confusion. Here's what I'm trying to do.
I basically have the following structures at present:
// tag object
typedef struct {
uint8_t data[MAX_TAG_LENGTH_IN_BYTES];
uint32_t len;
} tlvTag_t;
// length object
typedef struct {
uint8_t data[MAX_LENGTH_OF_LENGTH_IN_BYTES];
uint32_t len;
} tlvLength_t;
typedef struct tlv tlv_t;
// value object definition
typedef struct {
// can consist of a byte array, or a list of sub TLVs
union {
uint8_t data[MAX_VALUE_LENGTH_IN_BYTES];
// data can be parsed into subTLVs
tlv_t* subTLVs;
};
// need to store the number of subTLVs
uint32_t numberOfSubTLVs;
// len is the total length of the data represented:
// the total length of the subTLVs placed end to end
// or the length of the data array.
uint32_t len;
} tlvValue_t;
// tlv object definition
struct tlv {
tlvTag_t tag;
tlvLength_t len;
tlvValue_t value;
// total length of entire tlv block (not value length)
// (if there are sub TLVs, place them end to end)
uint32_t totalLen;
};
I thought the design would be better if I could wrap the arrays in another struct to avoid all the code duplication and be able to pass fewer arguments around, but I can't because I don't know how to tell the compiler to create different sized byte arrays - maybe it's possible using macros? Hope that makes sense.

Answer 1

It seems you are trying to somehow declare a struct whose contents depend on a parameter. In c++ this could be implemented by a template:
template <size_t MAX_LEN>
struct byteArray_t
{
uint8_t data[MAX_LEN];
size_t len;
};
...
byteArray_t<MAX_TAG_LENGTH_IN_BYTES> tag;
byteArray_t<MAX_LENGTH_OF_LENGTH_IN_BYTES> len;
...
This is as straightforward as it can get.
To accomplish the same in C, you can use macros:
#define DECLARE_BYTE_ARRAY_T(your_type_name, MAX_LEN) \
typedef struct { \
uint8_t data[MAX_LEN]; \
size_t len; \
} your_type_name
DECLARE_BYTE_ARRAY_T(tlvTag_t, MAX_TAG_LENGTH_IN_BYTES);
DECLARE_BYTE_ARRAY_T(tlvLenght_t, MAX_LENGTH_OF_LENGTH_IN_BYTES);
...
tlvTag_t tag;
tlvLength_t len;
Or (the same) without declaring types (good if you don't need names for your structs):
#define BYTE_ARRAY_T(MAX_LEN) \
struct { \
uint8_t data[MAX_LEN]; \
size_t len; \
}
BYTE_ARRAY_T(MAX_TAG_LENGTH_IN_BYTES) tag;
BYTE_ARRAY_T(MAX_LENGTH_OF_LENGTH_IN_BYTES) len;
This may be marginally better than the code you already have. However, in my opinion, this is not worth the effort, because any non-trivial macro decreases readability of code.

Answer 2

If you make a struct like this and then pass it by value to a function, then the whole array gets passed by value. You do not want that.
Actually you don't need an array inside the struct, just declare it elsewhere.
typedef struct {
uint8_t* data;
size_t len;
} byteArray_t;
int main()
{
uint8_t some_array[X];
...
byteArray_t wrapper = {some_array, X};
some_function (&wrapper);
}