le_basics.h File Reference

Find the address of a containing structure or union, based on the address of one of its members.

If countPtr points to the count member of an object type my_class_t, then a pointer to that object should use this:

my_class_t* myObjPtr = CONTAINER_OF(countPtr, my_class_t, count);

Computes the index of a member within an array.

This code sample prints out "The 'w' is at index 6.":

const char message[] = "Hello world!";
const char* charPtr;
int i;
 
for (i = 0; i < sizeof(message); i++)
{
    if (message[i] == 'w')
    {
        charPtr = &message[i];
    }
}
 
printf("The 'w' is at index %zu.\n", INDEX_OF_ARRAY_MEMBER(message, charPtr));

Macro used to declare that a symbol should be shared outside the dynamic shared object in which it is defined.

This can be used with either a declaration or a definition.

E.g., with a declaration (perhaps in a header file):

LE_SHARED void my_Function();

E.g., with a definition (in a .c file):

LE_SHARED void my_OtherFunction()
{
    LE_INFO("Hello world.");
}

Computes number of members in an array at compile time.

Warning

Does NOT work for pointers to arrays.

Here's a code sample:

const char message[] = "Hello world!";
 
size_t x = NUM_ARRAY_MEMBERS(message);
 
printf("%lu\n", x);

Will print 13 on a 32-bit target.

But this example is incorrect:

const char message[] = "Hello world!";
const char* messagePtr = &message;
 
size_t x = NUM_ARRAY_MEMBERS(messagePtr);    // NO! BAD PROGRAMMER! BAD!
 
printf("%lu\n", x);

This function takes the characters as an argument and puts quotes around them.

Code sample:

const char name[] = STRINGIZE(foo);

Is seen by the compiler as

const char name[] = "foo";

The STRINGIZE() macro function passes names like macro definitions on the compiler's command-line. If the above code were changed to:

const char name[] = STRINGIZE(NAME);

then compiling it using the following command line makes it equivalent to the example above:

$ gcc -c -DNAME=foo file.c

The -DNAME=foo defines a macro called NAME with a value foo. The C preprocessor then replaces STRINGIZE(NAME) with "foo".

Helper macro for STRINGIZE(x).

ON/OFF type.

Standard result codes.

Note

All error codes are negative integers. They allow functions with signed integers to return non-negative values when successful or standard error codes on failure.

Deprecated:

the result code LE_NOT_POSSIBLE is scheduled to be removed.