Metaprogramming with aggressive inlining

Macros are language constructs for generating boilerplate code. An inlined and optimized function with constant arguments can be a particular case of a LISP-like macro. Most C++ compilers support inlining and dead code elimination, so you can do some limited metaprogramming with them.

Checking modifier keys

Here is a small example. When handling WM_KEYDOWN message, you often need to check the state of modifier keys (Alt, Ctrl, and Shift) with GetKeyState. The function should usually be called 3 times for each modifier key. This would allow you to distinguish, say, Shift+F2 from Alt+Shift+F2. However, there are some cases where you would wish to ignore one modifier key.

The natural solution is a function taking two arguments: the desired key state (expressed with bit flags; one bit for each modifier key) and the mask of keys to check for. The function returns true if the needed keys were pressed and all other keys were not pressed:

// Implementation
BOOL inline KEY_PRESSED(int key) {
    return GetKeyState(key) < 0;
}

#define MOD_NO 0
BOOL __forceinline CheckModifiers(INT keys,
                                  INT mask = MOD_ALT | MOD_CTRL | MOD_SHIFT)
{
    return
        ( (mask & MOD_ALT  ) == 0 || ( keys       & 1) == KEY_PRESSED(VK_ALT  ) ) &&
        ( (mask & MOD_CTRL ) == 0 || ((keys >> 1) & 1) == KEY_PRESSED(VK_CTRL ) ) &&
        ( (mask & MOD_SHIFT) == 0 || ((keys >> 2) & 1) == KEY_PRESSED(VK_SHIFT) );
}

// Usage
case WM_KEYDOWN:
    if(wParam == 'C' && CheckModifiers(MOD_CTRL))
        CopyText();
    else if(wParam == VK_TAB && // Ctrl+Tab or Ctrl+Shift+Tab
            CheckModifiers(MOD_CTRL, MOD_CTRL | MOD_ALT))
        SwitchTabs();

The unneeded function calls are optimized away by MSVC, so this code will be effectively generated:

// if(wParam == 'C' && CheckModifiers(MOD_CTRL))
if(wParam == 'C' && GetKeyState(VK_ALT) >= 0 &&
    GetKeyState(VK_CTRL) < 0 && GetKeyState(VK_SHIFT) >= 0)

// if(wParam == VK_TAB && CheckModifiers(MOD_CTRL, MOD_CTRL | MOD_ALT))
if(wParam == VK_TAB && GetKeyState(VK_ALT) >= 0 &&
    GetKeyState(VK_CTRL) < 0)

The CheckModifiers function works as a LISP macro here.

Using small languages

In more complex cases, the compiler cannot optimize function calls. For example, sprintf with a constant format string could be replaced with appropriate conversion functions for each argument:

// sprintf(s, "%d items, %d seconds", items, seconds);
char * p = s;
p = print_int(p, items);
p = print_str(p, " items, ");
p = print_int(p, seconds);
    print_str(p, " seconds");

This would be more effective than string interpretation at run time. Most compilers do not perform such aggressive optimization, but it's theoretically possible. FreePascal implements writeln in such fashion, but it works only for that function. A generalization would make little languages (regular expressions, sscanf, printf, etc.) nearly as effective as hand-written code.

Applying functions without side effects to constants

PRR found another example: calling strlen function with a literal string, which can be optimized by MSVC and GCC. It would be more useful if you could use this trick for any function without side effects. For example, why can't you define the pi number through arcsine?

const double M_PI = 2 * asin(1); // Not valid C++

Or write an integer constant in binary using your own conversion function:

const int N = from_binary("010111"); // Not valid C++

In C++, you have to use tricky preprocessor macros or magic numbers for that.

An idea: unifying macros and functions

The asin and from_binary can be useful when called as a macro (with constant arguments) or a function (with variables). Instead of separating these concepts (as LISP does), a programming language could allow you to specify when an actual argument is substituted for the given formal parameter, at compile time or at run time. Something like that:

int sprintf(char * buffer, compile_time const char * format, ...); // Not valid C++

If format is a constant, it will be propagated to the function body and the resulting code will be inlined to the place where sprintf was called. If format is a variable, sprintf will be called as a usual function. What do you think about this idea?