GNU C Extensions cheatsheet

Using __extension__ prevent -pedantic warning

with __extension__

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

/* with __extension__ */
#define lambda(ret_type, ...)               \
        __extension__                       \
        ({                                  \
                ret_type __fn__ __VA_ARGS__ \
                __fn__;                     \
        })

int main(int argc, char *argv[])
{
        int a = 5566, b = 9527;
        int c = __extension__ 0b101010;
        int (*max) (int, int) = lambda(int, (int x, int y) {return x > y ? x : y; });

        printf("max(%d, %d) = %d\n", a, b, max(a, b));
        printf("binary const c = %x\n", c);

        return 0;
}
#endif

output:

$ gcc -g -Wall -std=c99 -pedantic test.c
$ ./a.out
max(5566, 9527) = 9527
binary const c = 2a

without __extension__

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

/* with __extension__ */
#define lambda(ret_type, ...)               \
        ({                                  \
                ret_type __fn__ __VA_ARGS__ \
                __fn__;                     \
        })

int main(int argc, char *argv[])
{
        int a = 5566, b = 9527;
        int c = 0b101010;
        int (*max) (int, int) = lambda(int, (int x, int y) {return x > y ? x : y; });

        printf("max(%d, %d) = %d\n", a, b, max(a, b));
        printf("binary const c = %x\n", c);

        return 0;
}
#endif

output:

$ gcc -g -Wall -pedantic test.c
test.c: In function 'main':
test.c:17:17: warning: binary constants are a GCC extension [enabled by default]
         int c = 0b101010;
                 ^
test.c:18:40: warning: ISO C forbids nested functions [-Wpedantic]
         int (*max) (int, int) = lambda(int, (int x, int y) {return x > y ? x : y; });
                                        ^
test.c:10:17: note: in definition of macro 'lambda'
                 ret_type __fn__ __VA_ARGS__ \
                 ^
test.c:9:9: warning: ISO C forbids braced-groups within expressions [-Wpedantic]
         ({                                  \
         ^
test.c:18:33: note: in expansion of macro 'lambda'
         int (*max) (int, int) = lambda(int, (int x, int y) {return x > y ? x : y; });
                                 ^
$ ./a.out
max(5566, 9527) = 9527
binary const c = 2a

Binary Constants

ref: Binary Constants

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

int main(int argc, char *argv[])
{
        int a = 0b0101;
        int b = 0x003a;

        printf("%x, %x\n", a, b);

        return 0;
}
#endif

output:

$ gcc -g -Wall -pedantic test.c
test.c: In function 'main':
test.c:9:17: warning: binary constants are a GCC extension [enabled by default]
         int a = 0b0101;
                 ^
$ ./a.out
./a.out
5, 3a

Statements and Declarations in Expressions

ref: Statements and Declarations in Expressions

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

#define square(x)   \
  ({                \
        int y = 0;  \
        y = x * x;  \
        y;          \
   })

#define max(a, b)           \
  ({                        \
        typeof (a) _a = a;  \
        typeof (b) _b = b;  \
        _a > _b ? _a : _b;  \
   })

int main(int argc, char *argv[])
{
        int x = 3;
        int a = 55, b = 66;
        printf("square val: %d\n", square(x));
        printf("max(%d, %d) = %d\n", a, b, max(a, b));
        return 0;
}

#endif

output:

$ ./a.out
square val: 9
max(55, 66) = 66

Locally Declared Labels

ref: Locally Declared Labels

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

#define ARRAYSIZE(arr)                          \
  ({                                            \
        size_t size = 0;                        \
        size = sizeof(arr) / sizeof(arr[0]);    \
        size;                                   \
   })

#define SEARCH(arr, size, target)           \
  ({                                        \
        __label__ found;                    \
        int i = 0;                          \
        int value = -1;                     \
        for (i = 0; i < size; i++) {        \
                if (arr[i] == target) {     \
                        value = i;          \
                        goto found;         \
                }                           \
        }                                   \
        value = -1;                         \
        found:                              \
        value;                              \
   })

int main(int argc, char *argv[])
{
        int arr[5] = {1, 2, 3, 9527, 5566};
        int target = 9527;

        printf("arr[%d] = %d\n",
                SEARCH(arr, ARRAYSIZE(arr), target), target);
        return 0;
}

#endif

output:

$ ./a.out
arr[3] = 9527

Nested Functions

ref: Nested Functions

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

int main(int argc, char *argv[])
{
        double a = 3.0;
        double square(double x) { return x * x; }

        printf("square(%.2lf) = %.2lf\n", a, square(a));
        return 0;
}
#endif

output:

$ ./a.out
square(3.00) = 9.00

Note

The nested function can access all the variables of the containing function that are visible at the point of its definition. This is called lexical scoping.

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

int main(int argc, char *argv[])
{
        int i = 0;

        void up(void) { i++; }
        printf("i = %d\n", i);
        up();
        printf("i = %d\n", i);
        up();
        printf("i = %d\n", i);

        return 0;
}
#endif

output:

./a.out
i = 0
i = 1
i = 2

Note

It is possible to call the nested function from outside the scope of its name by storing its address or passing the address to another function.

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

#define ARRAY_SIZE(arr) sizeof(arr) / sizeof(arr[0])
void print_str(char **arr, int i, char *(*access)(char **arr, int idx))
{
        char *ptr = NULL;

        if (arr == NULL) return;

        ptr = access(arr, i);
        if (ptr != NULL) {
                printf("str = %s\n", ptr);
        }
}

int main(int argc, char *argv[])
{
        char *arr[5] = {"Hello", "World", "Foo", "Bar", NULL};
        char *ptr = NULL;
        int i = 0;
        int offset = 1;

        char *access(char **arr, int idx)
        {
                return arr[idx + offset];
        }

        for (i = 0; i < (ARRAY_SIZE(arr) - offset); i++) {
                print_str(arr, i, access);
        }

    return 0;
}
#endif

output:

$ ./a.out
str = World
str = Foo
str = Bar

Note

A nested function can jump to a label inherited from a containing function, provided the label is explicitly declared in the containing function.

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

int main(int argc, char *argv[])
{
        __label__ end;
        int ret = -1, i = 0;

        void up(void)
        {
                i++;
                if (i > 2) goto end;
        }
        printf("i = %d\n", i); /* i = 0 */
        up();
        printf("i = %d\n", i); /* i = 1 */
        up();
        printf("i = %d\n", i); /* i = 2 */
        up();
        printf("i = %d\n", i); /* i = 3 */
        up();
        printf("i = %d\n", i); /* i = 4 */
        up();
        ret = 0;
end:
        return ret;
}
#endif

output:

$ ./a.out
i = 0
i = 1
i = 2

Note

If you need to declare the nested function before its definition, use auto (which is otherwise meaningless for function declarations).

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

int main(int argc, char *argv[])
{
        int i = 0;
        auto void up(void);

        void up(void) { i++; }
        printf("i = %d\n", i); /* i = 0 */
        up();
        printf("i = %d\n", i); /* i = 1 */
        up();
        printf("i = %d\n", i); /* i = 2 */
        up();
        return 0;
}
#endif

output:

$ ./a.out
i = 0
i = 1
i = 2

Referring to a Type with typeof

ref: Referring to a Type with typeof

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

#define pointer(T)  typeof(T *)
#define array(T, N) typeof(T [N])

int g_arr[5];

int main(int argc, char *argv[])
{
        int i = 0;
        char **ptr = NULL;

        /* This declares _val with the type of what ptr points to. */
        typeof (*g_arr) val = 5566;
        /* This declares _arr as an array of such values. */
        typeof (*g_arr) arr[3] = {1, 2,3};
        /* This declares y as an array of pointers to characters.*/
        array (pointer (char), 4) str_arr = {"foo", "bar", NULL};

        printf("val: %d\n", val);
        for (i = 0; i < 3; i++) {
                printf("arr[%d] = %d\n", i, arr[i]);
        }
        for (i = 0, ptr = str_arr; *ptr != NULL ; i++, ptr++) {
                printf("str_arr[%d] = %s\n", i, *ptr);
        }

        return 0;
}
#endif

output:

$ ./a.out
val: 5566
arr[0] = 1
arr[1] = 2
arr[2] = 3
str_arr[0] = foo
str_arr[1] = bar

Conditionals with Omitted Operands

ref: Conditionals with Omitted Operands

Note

The middle operand in a conditional expression may be omitted. Then if the first operand is nonzero, its value is the value of the conditional expression.

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

int main(int argc, char *argv[])
{
        int x = 1, y = 0;
        int z = -1;

        /* equivalent to x ? x : y */
        z = x ? : y;
        printf("z = %d\n", z);
        return 0;
}

output:

$ ./a.out
z = 1

Arrays of Length Zero

Note

Zero-length arrays are allowed in GNU C. They are very useful as the last element of a structure which is really a header for a variable-length object

#include <stdlib.h>
#include <errno.h>
#include <string.h>

#define CHECK_NULL(ptr, fmt, ...)                   \
        do {                                        \
                if (!ptr) {                         \
                        printf(fmt, ##__VA_ARGS__); \
                        goto End;                   \
                }                                   \
        } while(0)

/* array item has zero length */
typedef struct _list {
        int len;
        char *item[0];
} list;

int main(int argc, char *argv[])
{

        int ret = -1, len = 3;
        list *p_list = NULL;

        p_list = (list *)malloc(sizeof(list) + sizeof(char *) * len);
        CHECK_NULL(p_list, "malloc fail. [%s]", strerror(errno));

        p_list->item[0] = "Foo";
        p_list->item[1] = "Bar";
        p_list->item[2] = NULL;

        printf("item[0] = %s\n", p_list->item[0]);
        printf("item[1] = %s\n", p_list->item[1]);
        printf("item[2] = %s\n", p_list->item[2]);

        ret = 0;
End:

        if (p_list)
                free(p_list);

        return ret;
}

#endif

output:

$ ./a.out
item[0] = Foo
item[1] = Bar
item[2] = (null)

Note

GCC allows static initialization of flexible array members

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

typedef struct _list {
        int len;
        int item[];
} list;

#define PRINT_LIST(l)                             \
        do {                                      \
                int i = 0;                        \
                for (i = 0; i < l.len; i++) {     \
                        printf("%d ", l.item[i]); \
                }                                 \
                printf("\n");                     \
        } while(0)

int main(int argc, char *argv[])
{
        static list l1 = {3, {1, 2, 3}};
        static list l2 = {5, {1, 2, 3, 4, 5}};

        PRINT_LIST(l1);
        PRINT_LIST(l2);
        return 0;
}

#endif

output:

$ ./a.out
1 2 3
1 2 3 4 5

Variadic Macros

ref: Variadic Macros

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

#define DEBUG_C99(fmt, ...)     fprintf(stderr, fmt, ##__VA_ARGS__)
#define DEBUG_GNU(fmt, args...) fprintf(stderr, fmt, ##args)

int main(int argc, char *argv[])
{
        DEBUG_C99("ISO C supported variadic macros\n");
        DEBUG_GNU("GNU C supported variadic macors\n");

        DEBUG_C99("ISO C format str = %s\n", "Foo");
        DEBUG_GNU("GNU C format str = %s\n", "Bar");

        return 0;
}
#endif

output:

$ ./a.out
ISO C supported variadic macros
GNU C supported variadic macors
ISO C format str = Foo
GNU C format str = Bar

Compound Literals (cast constructors)

ref: Compound Literals

Note

A compound literal looks like a cast containing an initializer. Its value is an object of the type specified in the cast, containing the elements specified in the initializer

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

int main(int argc, char *argv[])
{
        struct foo {int a; char b[3]; } structure = {};

        /* compound literals (cast constructors )*/

        structure = ((struct foo) { 5566, 'a', 'b'});
        printf("a = %d, b = %s\n", structure.a, structure.b);

        /* equal to */

        struct foo temp = {5566, 'a', 'b'};
        structure = temp;

        printf("a = %d, b = %s\n", structure.a, structure.b);

        return 0;
}
#endif

output:

$ ./a.out
a = 5566, b = ab
a = 5566, b = ab

Note

If the object being initialized has array type of unknown size, the size is determined by compound literal size

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

int main(int argc, char *argv[])
{
        /* The size is determined by compound literal size */

        static int x[] = (int []) {1, 2, 3, 4, 5};
        static int y[] = (int [3]) {1};
        int i = 0;

        for (i = 0; i < 5; i++) printf("%d ", x[i]);
        printf("\n");

        for (i = 0; i < 3; i++) printf("%d ", y[i]);
        printf("\n");

        /* equal to */

        static int xx[] = {1, 2, 3, 4, 5};
        static int yy[] = {1, 0, 0};

        for (i = 0; i < 5; i++) printf("%d ", xx[i]);
        printf("\n");

        for (i = 0; i < 3; i++) printf("%d ", yy[i]);
        printf("\n");

        return 0;
}
#endif

output:

./a.out
1 2 3 4 5
1 0 0
1 2 3 4 5
1 0 0

Case Ranges

ref: Case Ranges

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

int foo(int a)
{
        switch (a) {
                case 1 ... 3:
                        return 5566;
                case 4 ... 6:
                        return 9527;
        }
        return 7788;
}

int main(int argc, char *argv[])
{
        int b = 0;

        b = foo(1);
        printf("b = %d\n", b);

        b = foo(5);
        printf("b = %d\n", b);

        b = foo(10);
        printf("b = %d\n", b);

        return 0;
}
#endif

output:

$ ./a.out
b = 5566
b = 9527
b = 7788

Warning

Be careful, write spaces around the ... (ex: r1 ... r2), for otherwise it may be parsed wrong when you use it with integer values

Designated Initializers

ref: Initializers

Array initializer

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

#define ARRLEN 6

int main(int argc, char *argv[])
{
        /* ISO C99 support giving the elements in any order */
        int a[ARRLEN] = {[5] = 5566, [2] = 9527};
        /* equal to (ISO C90)*/
        int b[ARRLEN] = {0, 0, 9527, 0, 0, 5566};
        register int i = 0;

        for (i = 0; i < ARRLEN; i++) printf("%d ", a[i]);
        printf("\n");

        for (i = 0; i < ARRLEN; i++) printf("%d ", a[i]);
        printf("\n");

        return 0;
}
#endif

output:

$ # compile in C90 mode
$ gcc -std=c90 -pedantic test.c
test.c: In function 'main':
test.c:12:26: warning: ISO C90 forbids specifying subobject to initialize [-Wpedantic]
         int a[ARRLEN] = {[5] = 5566, [2] = 9527};
                          ^
test.c:12:38: warning: ISO C90 forbids specifying subobject to initialize [-Wpedantic]
         int a[ARRLEN] = {[5] = 5566, [2] = 9527};
                                      ^

$ # compile in C99 mode
$ gcc -std=c99 -pedantic test.c
$ ./a.out
0 0 9527 0 0 5566
0 0 9527 0 0 5566

Note

GNU C also support to initialize a range of elements to the same value

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

#define ARRLEN 10

int main(int argc, char *argv[])
{
        int arr[ARRLEN] = { [2 ... 5] = 5566, [7 ... 9] = 9527};
        register i = 0;

        for (i = 0; i< ARRLEN; i++) printf("%d ", arr[i]);
        printf("\n");

        return 0;
}
#endif

output:

$ gcc -pedantic test.c
test.c: In function 'main':
test.c:11:32: warning: ISO C forbids specifying range of elements to initialize [-Wpedantic]
         int arr[ARRLEN] = { [2 ... 5] = 5566, [7 ... 9] = 9527};
                                ^
test.c:11:29: warning: ISO C90 forbids specifying subobject to initialize [-Wpedantic]
         int arr[ARRLEN] = { [2 ... 5] = 5566, [7 ... 9] = 9527};
                             ^
test.c:11:50: warning: ISO C forbids specifying range of elements to initialize [-Wpedantic]
         int arr[ARRLEN] = { [2 ... 5] = 5566, [7 ... 9] = 9527};
                                                  ^
test.c:11:47: warning: ISO C90 forbids specifying subobject to initialize [-Wpedantic]
         int arr[ARRLEN] = { [2 ... 5] = 5566, [7 ... 9] = 9527};
                                               ^
$ ./a.out
0 0 5566 5566 5566 5566 0 9527 9527 9527

structure & union initializer

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

typedef struct _point {int x, y; } point;
typedef union _foo {int i; double d; } foo;


int main(int argc, char *argv[])
{
        point a = { 5566, 9527 };
        /* GNU C support initialize with .fieldname = */
        point b = { .x = 5566, .y = 9527 };
        /* obsolete since GCC 2.5 */
        point c = { x: 5566, y: 9527 };
        /* specify which element of the union should be used */
        foo bar = { .d = 5566 };

        printf("a.x = %d, a.y = %d\n", a.x, a.y);
        printf("b.x = %d, b.y = %d\n", b.x, b.y);
        printf("c.x = %d, c.y = %d\n", c.x, c.y);
        printf("bar.d = %.2lf\n", bar.d);

        return 0;
}
#endif

output:

$ gcc -pedantic test.c
test.c: In function 'main':
test.c:15:21: warning: ISO C90 forbids specifying subobject to initialize [-Wpedantic]
         point b = { .x = 5566, .y = 9527 };
                     ^
test.c:15:32: warning: ISO C90 forbids specifying subobject to initialize [-Wpedantic]
         point b = { .x = 5566, .y = 9527 };
                                ^
test.c:17:22: warning: obsolete use of designated initializer with ':' [-Wpedantic]
         point c = { x: 5566, y: 9527 };
                      ^
test.c:17:31: warning: obsolete use of designated initializer with ':' [-Wpedantic]
         point c = { x: 5566, y: 9527 };
                               ^
test.c:19:21: warning: ISO C90 forbids specifying subobject to initialize [-Wpedantic]
         foo bar = { .d = 5566 };
                     ^
test.c:24:9: warning: ISO C90 does not support the '%lf' gnu_printf format [-Wformat=]
         printf("bar.d = %.2lf\n", bar.d);
         ^
$ a.out
a.x = 5566, a.y = 9527
b.x = 5566, b.y = 9527
c.x = 5566, c.y = 9527
bar.d = 5566.00

Unnamed Structure and Union Fields

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

struct foo {
        int a;
        union {
                int b;
                char byte[4];
        };
        int d;
};

int main(int argc, char *argv[])
{

        struct foo bar = { 0x1a, { 0x2b }, 0x3c };
        int i = 0;

        printf("%x, %x, %x\n", bar.a, bar.b, bar.d);

        /* on little machine, we will get 2b 0 0 0 */
        for (i = 0; i < 4; i++) printf("%x ", bar.byte[i]);
        printf("\n");

        return 0;
}
#endif

output:

# without gcc options -std=c11 will raise warning
$ gcc -g -Wall -pedantic test.c
test.c:12:10: warning: ISO C90 doesn't support unnamed structs/unions [-Wpedantic]
         };
          ^
# with gcc options -std=c11 will not raise warning
$ gcc -g -Wall -pedantic -std=c11 test.c
$ ./a.out
1a, 2b, 3c
2b 0 0 0

Note

Unnamed field must be a structure or union definition without a tag like struct { int a; };. If -fms-extensions is used, the field may also be a definition with a tag such as struct foo { int a; };

#ifndef __GNUC__
#error "__GNUC__ not defined"
#else

#include <stdio.h>

struct foo {
        int b;
        int c;
};

struct bar {
        int a;
        struct foo;
        int d;
};

int main(int argc, char *argv[])
{
        struct bar baz = { 0x1a, { 0x2b, 0x00 }, 0x3c };

        printf("%x, %x, %x, %x\n", baz.a, baz.b, baz.c, baz.d);

        return 0;
}
#endif

output:

$ gcc -g -Wall -pedantic -std=c11 -fms-extensions test.c
$ ./a.out
1a, 2b, 0, 3c