stateful preprocessing

counter.h

// counter.h
//
// increment the value of the counter
// every time this file is included
//

// no guard, repeatable inclusion


#ifndef MY_COUNTER // starting value

  #define MY_COUNTER  0

#else

  #undef MY_COUNT_COPY_BIT_0
  #undef MY_COUNT_COPY_BIT_1
  #undef MY_COUNT_COPY_BIT_2
  #undef MY_COUNT_COPY_BIT_3
  #undef MY_COUNT_COPY_BIT_4
  #undef MY_COUNT_COPY_BIT_5
  #undef MY_COUNT_COPY_BIT_6
  #undef MY_COUNT_COPY_BIT_7
  #undef MY_COUNT_COPY_BIT_8
  #undef MY_COUNT_COPY_BIT_9
  #undef MY_COUNT_COPY_BIT_10
  #undef MY_COUNT_COPY_BIT_11
  #undef MY_COUNT_COPY_BIT_12
  #undef MY_COUNT_COPY_BIT_13
  #undef MY_COUNT_COPY_BIT_14
  #undef MY_COUNT_COPY_BIT_15

  #define MY_COUNT_COPY_BIT_0  0
  #define MY_COUNT_COPY_BIT_1  0
  #define MY_COUNT_COPY_BIT_2  0
  #define MY_COUNT_COPY_BIT_3  0
  #define MY_COUNT_COPY_BIT_4  0
  #define MY_COUNT_COPY_BIT_5  0
  #define MY_COUNT_COPY_BIT_6  0
  #define MY_COUNT_COPY_BIT_7  0
  #define MY_COUNT_COPY_BIT_8  0
  #define MY_COUNT_COPY_BIT_9  0
  #define MY_COUNT_COPY_BIT_10 0
  #define MY_COUNT_COPY_BIT_11 0
  #define MY_COUNT_COPY_BIT_12 0
  #define MY_COUNT_COPY_BIT_13 0
  #define MY_COUNT_COPY_BIT_14 0
  #define MY_COUNT_COPY_BIT_15 0

  #define MY_INCRVAL (MY_COUNTER + 1)

  // update new values for bits

  #if MY_INCRVAL & (1 << 0)
    #undef  MY_COUNT_COPY_BIT_0
    #define MY_COUNT_COPY_BIT_0 1
  #endif

  #if MY_INCRVAL & (1 << 1)
    #undef  MY_COUNT_COPY_BIT_1
    #define MY_COUNT_COPY_BIT_1 1
  #endif

  #if MY_INCRVAL & (1 << 2)
    #undef  MY_COUNT_COPY_BIT_2
    #define MY_COUNT_COPY_BIT_2 1
  #endif

  #if MY_INCRVAL & (1 << 3)
    #undef  MY_COUNT_COPY_BIT_3
    #define MY_COUNT_COPY_BIT_3 1
  #endif

  #if MY_INCRVAL & (1 << 4)
    #undef  MY_COUNT_COPY_BIT_4
    #define MY_COUNT_COPY_BIT_4 1
  #endif

  #if MY_INCRVAL & (1 << 5)
    #undef  MY_COUNT_COPY_BIT_5
    #define MY_COUNT_COPY_BIT_5 1
  #endif

  #if MY_INCRVAL & (1 << 6)
    #undef  MY_COUNT_COPY_BIT_6
    #define MY_COUNT_COPY_BIT_6 1
  #endif

  #if MY_INCRVAL & (1 << 7)
    #undef  MY_COUNT_COPY_BIT_7
    #define MY_COUNT_COPY_BIT_7 1
  #endif

  #if MY_INCRVAL & (1 << 8)
    #undef  MY_COUNT_COPY_BIT_8
    #define MY_COUNT_COPY_BIT_8 1
  #endif

  #if MY_INCRVAL & (1 << 9)
    #undef  MY_COUNT_COPY_BIT_9
    #define MY_COUNT_COPY_BIT_9 1
  #endif

  #if MY_INCRVAL & (1 << 10)
    #undef  MY_COUNT_COPY_BIT_10
    #define MY_COUNT_COPY_BIT_10 1
  #endif

  #if MY_INCRVAL & (1 << 11)
    #undef  MY_COUNT_COPY_BIT_11
    #define MY_COUNT_COPY_BIT_11 1
  #endif

  #if MY_INCRVAL & (1 << 12)
    #undef  MY_COUNT_COPY_BIT_12
    #define MY_COUNT_COPY_BIT_12 1
  #endif

  #if MY_INCRVAL & (1 << 13)
    #undef  MY_COUNT_COPY_BIT_13
    #define MY_COUNT_COPY_BIT_13 1
  #endif

  #if MY_INCRVAL & (1 << 14)
    #undef  MY_COUNT_COPY_BIT_14
    #define MY_COUNT_COPY_BIT_14 1
  #endif

  #if MY_INCRVAL & (1 << 15)
    #undef  MY_COUNT_COPY_BIT_15
    #define MY_COUNT_COPY_BIT_15 1
  #endif

  // update actual bits

  #undef MY_COUNT_BIT_0
  #undef MY_COUNT_BIT_1
  #undef MY_COUNT_BIT_2
  #undef MY_COUNT_BIT_3
  #undef MY_COUNT_BIT_4
  #undef MY_COUNT_BIT_5
  #undef MY_COUNT_BIT_6
  #undef MY_COUNT_BIT_7
  #undef MY_COUNT_BIT_8
  #undef MY_COUNT_BIT_9
  #undef MY_COUNT_BIT_10
  #undef MY_COUNT_BIT_11
  #undef MY_COUNT_BIT_12
  #undef MY_COUNT_BIT_13
  #undef MY_COUNT_BIT_14
  #undef MY_COUNT_BIT_15

  #define MY_COUNT_BIT_0  0
  #define MY_COUNT_BIT_1  0
  #define MY_COUNT_BIT_2  0
  #define MY_COUNT_BIT_3  0
  #define MY_COUNT_BIT_4  0
  #define MY_COUNT_BIT_5  0
  #define MY_COUNT_BIT_6  0
  #define MY_COUNT_BIT_7  0
  #define MY_COUNT_BIT_8  0
  #define MY_COUNT_BIT_9  0
  #define MY_COUNT_BIT_10 0
  #define MY_COUNT_BIT_11 0
  #define MY_COUNT_BIT_12 0
  #define MY_COUNT_BIT_13 0
  #define MY_COUNT_BIT_14 0
  #define MY_COUNT_BIT_15 0

  #if MY_COUNT_COPY_BIT_0
    #undef  MY_COUNT_BIT_0
    #define MY_COUNT_BIT_0 1
  #endif

  #if MY_COUNT_COPY_BIT_1
    #undef  MY_COUNT_BIT_1
    #define MY_COUNT_BIT_1 1
  #endif

  #if MY_COUNT_COPY_BIT_2
    #undef  MY_COUNT_BIT_2
    #define MY_COUNT_BIT_2 1
  #endif

  #if MY_COUNT_COPY_BIT_3
    #undef  MY_COUNT_BIT_3
    #define MY_COUNT_BIT_3 1
  #endif

  #if MY_COUNT_COPY_BIT_4
    #undef  MY_COUNT_BIT_4
    #define MY_COUNT_BIT_4 1
  #endif

  #if MY_COUNT_COPY_BIT_5
    #undef  MY_COUNT_BIT_5
    #define MY_COUNT_BIT_5 1
  #endif

  #if MY_COUNT_COPY_BIT_6
    #undef  MY_COUNT_BIT_6
    #define MY_COUNT_BIT_6 1
  #endif

  #if MY_COUNT_COPY_BIT_7
    #undef  MY_COUNT_BIT_7
    #define MY_COUNT_BIT_7 1
  #endif

  #if MY_COUNT_COPY_BIT_8
    #undef  MY_COUNT_BIT_8
    #define MY_COUNT_BIT_8 1
  #endif

  #if MY_COUNT_COPY_BIT_9
    #undef  MY_COUNT_BIT_9
    #define MY_COUNT_BIT_9 1
  #endif

  #if MY_COUNT_COPY_BIT_10
    #undef  MY_COUNT_BIT_10
    #define MY_COUNT_BIT_10 1
  #endif

  #if MY_COUNT_COPY_BIT_11
    #undef  MY_COUNT_BIT_11
    #define MY_COUNT_BIT_11 1
  #endif

  #if MY_COUNT_COPY_BIT_12
    #undef  MY_COUNT_BIT_12
    #define MY_COUNT_BIT_12 1
  #endif

  #if MY_COUNT_COPY_BIT_13
    #undef  MY_COUNT_BIT_13
    #define MY_COUNT_BIT_13 1
  #endif

  #if MY_COUNT_COPY_BIT_14
    #undef  MY_COUNT_BIT_14
    #define MY_COUNT_BIT_14 1
  #endif

  #if MY_COUNT_COPY_BIT_15
    #undef  MY_COUNT_BIT_15
    #define MY_COUNT_BIT_15 1
  #endif

  #undef MY_INCRVAL
#endif

// may have been manually reset
#undef MY_COUNTER
#define MY_COUNTER        ( \
  (MY_COUNT_BIT_0  << 0 ) | \
  (MY_COUNT_BIT_1  << 1 ) | \
  (MY_COUNT_BIT_2  << 2 ) | \
  (MY_COUNT_BIT_3  << 3 ) | \
  (MY_COUNT_BIT_4  << 4 ) | \
  (MY_COUNT_BIT_5  << 5 ) | \
  (MY_COUNT_BIT_6  << 6 ) | \
  (MY_COUNT_BIT_7  << 7 ) | \
  (MY_COUNT_BIT_8  << 8 ) | \
  (MY_COUNT_BIT_9  << 9 ) | \
  (MY_COUNT_BIT_10 << 10) | \
  (MY_COUNT_BIT_11 << 11) | \
  (MY_COUNT_BIT_12 << 12) | \
  (MY_COUNT_BIT_13 << 13) | \
  (MY_COUNT_BIT_14 << 14) | \
  (MY_COUNT_BIT_15 << 15) )

test.c

#include "counter.h"

#if MY_COUNTER != 0
#error "starts at zero"
#endif

#include "counter.h"

#if MY_COUNTER != 1
#error "one follows zero"
#endif

#include "counter.h"
#include "counter.h"
#include "counter.h"

#if MY_COUNTER != 4
#error "ha! ha! ha!"
#endif

#include "counter.h"
#include "counter.h"
#include "counter.h"

#if MY_COUNTER != 7
#error "etc."
#endif

#undef MY_COUNTER
#define MY_COUNTER 853

#include "counter.h"

#if MY_COUNTER != 854
#error "value is retargetable"
#endif

this is a simplification and extraction of the principle used to implement Boost's stateful-slots