gcc-warning

I have the following code, and while compiling it with gcc-4.6 I get warning: warning: variable ‘status’ set but not used [-Wunused-but-set-variable] #if defined (_DEBUG_) #define ASSERT assert #else /* _DEBUG_ */ #define ASSERT( __exp__ ) #endif static inline void cl_plock(cl_plock_t * const p_lock) { status_t status; ASSERT(p_lock); ASSERT(p_lock->state == INITIALIZED); status = pthread_rwlock_unlock(&p_lock->lock); ASSERT(status == 0); } When _DEBUG_ flag isn't set I get the warning. Any ideas how can I workaround this warning? You can change your ASSERT macro to: #if defined (_DEBUG_)

The following program has undefined behavior: #include <stdio.h> int main(void) { unsigned int x = -100; // This is fine, becomes UINT_MAX - 100 printf("%d\n", x); // This is undefined behavior. return 0; } C99 7.19.6.1p8 states %d expects an int argument. C99 7.19.6.1p9 states "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined ." However, gcc -Wformat (which is included with -Wall ) will not complain about the above program, why? Is this a bug, or a deliberate omission? From the gcc manpage: -Wformat Check calls to "printf" and

The newer versions of gcc offer the Wimplicit-fallthrough , which is great to have for most switch statements. However, I have one switch statement where I want to allow fall throughs from all case-statements. Is there a way to do an explicit fall through? I'd prefer to avoid having to compile with Wno-implicit-fallthrough for this file. EDIT: I'm looking for a way to make the fall through explicit (if it's possible), not to turn off the warning via a compiler switch or pragma. Use __attribute__ ((fallthrough)) switch (condition) { case 1: __attribute__ ((fallthrough)); case 2: __attribute__ (

I found this in a multi-threaded c application. The authors commented that it's used to make a thread crash in a custom assert function. GCC is fine with it, but clang issues the following warning: note: consider using __builtin_trap() or qualifying pointer with 'volatile' and also issues one of those, for each usage of the assert function: warning: indirection of non-volatile null pointer will be deleted, not trap What is going on here? Is __builtin_trap specific to clang? Should I use it? Writing to NULL address is not guaranteed to crash your program reliably, so GCC introduced __builtin

I had just taken the decision to change as many variables from unsigned to int and upon recompiling the code in question, was greeted by this warning message: freespace_state.c:203: warning: assuming that the loop is not infinite The line in question: for (x = startx; x <= endx; ++x, ++xptr) This loop is 60 lines of code (inc white space/brackets etc), and has a goto within it, and at least one occurrence of continue . In this case, I think I am appreciative that GCC is assuming this loop is not infinite, because, it should never loop indefinitely. What is GCC trying to tell me here? The

Initializing an array (in C++, but any solution which works for C will likely work here as well) with less initializers than it has elements is perfectly legal: int array[10] = { 1, 2, 3 }; However, this can be a source of obscure bugs. Is there a way to have the compiler (gcc) check the number of initializers for one specific array, and emit a warning or even an error if declared and actual size don't match? I know I can use int array[] = { 1, 2, 3 }; and could then use static assertions involving sizeof(array) to verify my expectation there. But I'm using array in other translation units, so

Wiki says: The extern keyword means "declare without defining". In other words, it is a way to explicitly declare a variable, or to force a declaration without a definition. It is also possible to explicitly define a variable, i.e. to force a definition. It is done by assigning an initialization value to a variable . That means, an extern declaration that initializes the variable serves as a definition for that variable . So, /* Just for testing purpose only */ #include <stdio.h> extern int y = 0; int main(){ printf("%d\n", y); return 0; } should be valid ( compiled in C++11 ). But when