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:

    1 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.":

    1 const char message[] = "Hello world!";
    2 const char* charPtr;
    3 int i;
    4 
    5 for (i = 0; i < sizeof(message); i++)
    6 {
    7     if (message[i] == 'w')
    8     {
    9         charPtr = &message[i];
   10     }
   11 }
   12 
   13 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):

    1 LE_SHARED void my_Function();

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

    1 LE_SHARED void my_OtherFunction()
    2 {
    3     LE_INFO("Hello world.");
    4 }

Computes number of members in an array at compile time.

Warning

Does NOT work for pointers to arrays.

Here's a code sample:

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

Will print 13 on a 32-bit target.

But this example is incorrect:

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

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

Code sample:

    1 const char name[] = STRINGIZE(foo);

Is seen by the compiler as

    1 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:

    1 const char name[] = STRINGIZE(NAME);

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

    1 $ 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.