第十三號艦隊

void DosomethingWithInt(int v);
void DosomethingWithFloat(float v);
DosomethingWithInt(1);
DosomethingWithFloat(3.14f);

define Dosomething(X) _Generic((X),  \
        int: DosomethingWithInt,  \
        float: DosomethingWithFloat)(X)
Dosomething(1);
Dosomething(3.14f);

void init_Obj(Obj *this, int v) 
void uninit_Obj(Obj *this);
int Dosomething()
{
        Obj local;
        init_Obj(&local, 10);
        int result = Doanotherthing(&local);
        uninit_Obj(&local);
        return result;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>

// Allocates RWX memory of given size and returns a pointer to it. On failure,
// prints out the error and returns NULL.
void* alloc_executable_memory(size_t size) {
  void* ptr = mmap(0, size,
                   PROT_READ | PROT_WRITE | PROT_EXEC,
                   MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
  if (ptr == (void*)-1) {
    perror("mmap");
    return NULL;
  }
  return ptr;
}

void emit_code_into_memory(unsigned char* m) {
  unsigned char code[] = {
    0x48, 0x89, 0xf8,                   // mov %rdi, %rax
    0x48, 0x83, 0xc0, 0x04,             // add $4, %rax
    0xc3                                // ret
  };
  memcpy(m, code, sizeof(code));
}

const size_t SIZE = 1024;
typedef long (*JittedFunc)(long);

// Allocates RWX memory directly.
void run_from_rwx() {
  void* m = alloc_executable_memory(SIZE);
  emit_code_into_memory(m);

  JittedFunc func = m;
  int result = func(2);
  printf("result = %d\n", result);
}

// Instead of
x = x ? x : 10;

// We can use the shorter form:
x = x ?: 10;

struct {
    float x, y, z;
};

demo.c:5:1: warning: declaration does not declare anything [-Wmissing-declarations]
struct {
^~~~~~
1 warning generated.

typedef union {
    struct { float x, y, z; };
    struct { vec2_t xy; };
    struct { float x_; vec2_t yz; };
    float v[3];
} vec3_t;
#define VEC3(x, y, z) { {x, y, z} }

vec3_t vec = VEC3(1, 2, 3);
// We can access the attributes in different ways.
float  x    = vec.x;
vec2_t xy   = vec.xy;
float  z    = vec.v[2];

// As used in the linux kernel.
// A macro that expands to 1 if a preprocessor value
// was defined to 1, and 0 if it was not defined or
// defined to an other value.

#define IS_DEFINED(macro) IS_DEFINED_(macro)
#define MACROTEST_1 ,
#define IS_DEFINED_(value) IS_DEFINED__(MACROTEST_##value)
#define IS_DEFINED__(comma) IS_DEFINED___(comma 1, 0)
#define IS_DEFINED___(_, v, ...) v

// Can be used in preprocessor macros:
#if IS_DEFINED(SOMETHING)
    ...
#endif

// Or even directly in the code.
// Same effect but looks better.
if (IS_DEFINED(SOMETHING)) {
    ...
}

// Not really special, but so useful I thought
// I'll put it here.  Can also be used with other
// libraries (OpenAL, OpenSLES, ...)
#ifdef DEBUG
#  define GL(line) do {                      \
       line;                                 \
       assert(glGetError() == GL_NO_ERROR);  \
   } while(0)
#else
#  define GL(line) line
#endif

// Put GL around all your opengl calls:
GL(glClear(GL_COLORS_MASK));
GL(pos_loc = glGetAttribLocation(prog, "pos"));

// Is there any C project that does not use it?
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))

// Can be used like this:
int a[] = {0, 4, 5, 6};
int n = ARRAY_SIZE(a); // n = 4

// Warning: does not work with array arguments to functions:
int func(int a[]) {
    int nb = ARRAY_SIZE(a); // Would not work!
}

#define min(a, b) ({ \
      __typeof__ (a) _a = (a); \
      __typeof__ (b) _b = (b); \
      _a < _b ? _a : _b; \
})

void func(const int *arg);
// Instead of using a local variable.
int tmp[] = {10, 20, 30};
func(tmp);

// We can write.
func( (const int[]){10, 20, 30} );

// Can be useful with a helper macro.
#define VEC(...) ((const int[]){__VA_ARGS__})
func(VEC(10, 20, 30));

typedef struct {
    float x, y;
} vec2_t;
void func(const vec2_t *arg);
#define make_struct(T, ...) (&(const T){ __VA_ARGS__})
func(make_struct(vec2_t, .y = 9999, .x = 20));

// I use this one all the time when writing
// video game.  One of the reason why I
// don't like to use C++.

// Let say we have this struct
struct obj {
    const char *name;
    float pos[2];
    float color[4];
};

// We can write a macro like this one
#define OBJ(_name, ...)             \
    (struct obj) {                  \
        .name = _name,              \
        .color = {1, 1, 1, 1},      \
        __VA_ARGS__                 \
    };

// Now we can use the macro to create new objects.
// This one with color defaulted to {1, 1, 1, 1}.
struct obj o1 = OBJ("o1", .pos = {0, 10});
// This one with pos defaulted to {0, 0}.
struct obj o2 = OBJ("o2", .color = {1, 0, 0, 1});

#define COLORS \
    X(Cred, "red") \
    X(Cblue, "blue") \
    X(Cgreen, "green")
    
#define X(a, b) a,
enum Color { COLORS };
#undef X
#define X(a, b) b,
static char *ColorStrings[] = { COLORS };
#undef X