le_basics.h File Reference

Format specifiers for size_t

Macro to help concatenate preprocessor tokens while first allowing macro expansion of those tokens.

Original source: https://github.com/pfultz2/Cloak/wiki/C-Preprocessor-tricks,-tips,-and-idioms

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));

Test if a KConfig feature is enabled.

LE_DECLARE_INLINE

Declare an inline function in a header.

GNU by default uses a non-standard method of declaring inline functions with the exact opposite meaning of the C99 standard.

So use LE_DECLARE_INLINE with the function body in a header. Then use LE_DEFINE_INLINE with just the function prototype in a .c file to tell the compiler to emit the function definition for cases where the function is not inlined.

This is preferred over using "static inline" since if a static inline function is not inlined by gcc, there may be multiple copies of the function included in the output. LE_DEFINE_INLINE

Cause a function definition to be emitted for an inline function, in case the compiler decides not to use the inline definition.

See also

LE_DECLARE_INLINE

If the macro passed as the first parameter is defined in the form ,

(note the leading comma) this evaluates to

. If the macro is not defined in this format (or not defined at all, this evaluates to the second, default parameter.

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.");
}

Mark a variable as unused.

Parameters

v	Variable to mark as unused.

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);

Helper macro for STRINGIZE(x).

Helper macro for SECOND(...). Always select the second parameter.

Provide static_assert if not available.

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.

If the compiler is armcc, allow anonymous unions, as these are useful and used quite a bit in Legato 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.