No problem can be solved at the same level of thinking that created it.¹ — “Albert Einstein”

Consistency Challenge

The first time I ran into X Macros was while debugging an out-of-bounds access issue.

Here is a simplified example:

// a.h
typedef enum {
    SYS_OK,
    SYS_ERR_TIMEOUT,
    SYS_ERR_BUSY,
    SYS_ERR_INVALID_ARG,
    SYS_ERR_NOT_FOUND
} SysState;

// a.c
const char *state_desc[] = {
    [SYS_OK] = "System OK",
    [SYS_ERR_TIMEOUT] = "Timeout",
    [SYS_ERR_BUSY] = "System Busy",
    [SYS_ERR_INVALID_ARG] = "Invalid Argument"
    // SYS_ERR_NOT_FOUND is missing here
};

int main()
{
    printf("State = %s\n", state_desc[SYS_ERR_NOT_FOUND]);
}

The issue is easy to spot: SYS_ERR_NOT_FOUND was added to the enum, but the string table was not updated.

When the program evaluates state_desc[SYS_ERR_NOT_FOUND], it reads past the end of the array and eventually crashes.

Of course, we could fix this by adding the missing entry to the string table. But that only fixes this specific bug — it does not prevent the same type of problem from happening again.

The underlying issue is that we are maintaining two pieces of information that must always stay consistent:

• the enum definition
• the string table

As long as these are maintained separately and rely on manual synchronization, mistakes like this are inevitable.

What we really need is a way to eliminate this class of problems entirely.

X Macros

While looking for a solution, I came across an article by Randy Meyers published in Dr. Dobb’s Journal titled The New C: X Macros ². The article introduces a technique that uses the C preprocessor to generate code from a single data definition.

This technique is commonly known as X Macros.

The idea is simple: maintain a single data list, and generate the necessary code structures by redefining a macro.

Let’s modify the previous example to see how this works.

First, define a Single source of truth:

#define SYS_STATE_LIST                         \
    X(SYS_OK,              "System OK")        \
    X(SYS_ERR_TIMEOUT,     "Timeout")          \
    X(SYS_ERR_BUSY,        "System Busy")      \
    X(SYS_ERR_INVALID_ARG, "Invalid Argument") \
    X(SYS_ERR_NOT_FOUND,   "Not Found")

This list becomes the master definition of our data. Each entry is wrapped inside a placeholder macro X().

The name X is simply a convention. It has no special meaning and can be replaced with any name.

Next, we define the macro X to generate the enum:

#define X(name, desc) name,
typedef enum {
    SYS_STATE_LIST
} SysState;
#undef X

Then we redefine X so that the same list generates the string table:

#define X(name, desc) [name] = desc,
const char *state_desc[] = {
    SYS_STATE_LIST
};
#undef X

If you come from dynamic languages such as Python or Java, this might look somewhat like a lightweight form of reflection.

X Macros gather scattered information into a single data list. By redefining and undefining X (#undef), the same data can be injected into multiple code templates. Adding, removing, or reordering entries will not introduce inconsistencies.

This technique works well in many situations where related data must stay synchronized, for example:

• Managing error codes, states, or event types together with their descriptions
• Generating command tables or protocol definitions
• Serialization and deserialization
• Configuration data initialization and access code generating

Advanced Notes

X Macros are powerful, but they do come with trade-offs. Macro-heavy code can reduce readability and make debugging more difficult.

Some practical tips:

• Improve readability: Andrew Lucas suggests passing the macro X as a parameter to the data list to make the structure clearer ³.

• Large data sets: If the list becomes very long, you may hit compiler line-length limits. Randy Meyers recommends placing the list in a separate.def or .h file and using #include to reuse it.

• Inspect preprocessed output: You can use gcc -E to view the expanded source code. Many modern IDEs with language servers can also show this.

• Team communication: Not everyone is familiar with this technique. Good comments and documentation help avoid confusion.

• Use it sparingly: Like most macro tricks, X Macros should be used thoughtfully rather than everywhere.

Summary

X Macros are essentially a lightweight metaprogramming technique built on top of the C/C++ preprocessor. In environments without reflection or code generation tools, they provide a practical way to keep related definitions synchronized.

By maintaining a Single Source of Truth and generating code through macro expansion, X Macros eliminate the risk of inconsistent duplicated definitions.

The idea dates back to assembly programming in the 1960s. Even today, whenever large amounts of structured data need to remain consistent, it remains a surprisingly useful technique — and a valuable tool in the C/C++ programmer’s toolbox.

One of the most common conflicts is with the command set-mark-command, which default binding is C-SPC~(Ctrl+Space)¹. On Windows, Ctrl+Space is often used to toggle between English and Chinese input methods, which can makeCtrl+Space unusable for marking in Emacs.

To resolve this issue, you can either use the alternative binding forset-mark-command, C-@, or disable the Ctrl+Space functionality in Windows. Additionally, since the spacebar can be operated easily with either thumb, there is a “third option”: you can configure the Ctrl+Space so that one side Ctrl+Space is reserved for Windows, while the other side Ctrl+Space is available for Emacs or other applications. This is the solution I adopted because it allows me to maintain my habit of using both thumbs for operation.

In the latest version of Windows 11, you can achieve this as follows:

1. Go to Settings > Time & Language > Language & region > Options > Microsoft Pinyin > Keys, and uncheck the Ctrl + Space box while leaving Shift checked.

2. Open PowerToys (install it if you don’t already have it). In the Keyboard Manager section, add a key remapping: map Ctrl(Left) + Space to Shift orWin(Left) + Space.

For older versions of Windows, where there’s a UI bug preventing such changes ², you can solve this by manually editing the registry:

1. Navigate to HKEY_CURRENT_USER\Control Panel\Input Method\Hot Keys\00000010. Modify the value of Key Modifiers to 02 80 00 00, or 02 40 00 00 ³.
2. If you want to apply this change for all new users, make the same modification under HKEY_USERS\.DEFAULT\Control Panel\Input Method\Hot Keys\00000010.

After making these changes, restart your computer to take effect.

It seems that only Ctrl+Space can be “split,” as other key combinations are naturally easier to reach with one hand. For example, Ctrl+a inherently impliesRight Ctrl+a.

This is an essential configuration for all the computers I use, all because of Emacs.

Emacs was originally developed as a set of macros for the TECO editor (Editing MACroS). At that time, the keyboard layout used by the developers placed the Ctrl key next to the spacebar¹, making it convenient for operation with the thumbs. For some reason, standard keyboards that became widespread with personal computers moved the Ctrl key to the outermost position, which forces usage with the pinky finger. This design easily fatigues the pinky.

Therefore, I choose to swap the Ctrl and Alt keys, returning the Ctrl key to a thumb-operable position, alleviating pinky strain and significantly improving efficiency.

Here’s how I do it:

• Windows: Using SharpKeys for key remapping.
• Linux (GNOME desktop): GNOME Tweak Tool makes this easy to configure².

This is a “once-you-use-it-you-can’t-go-back” configuration. It also has a‘hidden feature’ - driving others crazy when they try to use my keyboard.