Abstract:

This talk presents a personal C++23 project for declarative binary format parsing, aiming to replace handwritten boilerplate and code generators. The speaker, Hari Prasad Manoharan, details the development of an embedded Domain-Specific Language (DSL) using template metaprogramming (TMP). This DSL allows developers to define complex binary layouts, including conditional fields and length-prefixed data, in a declarative style.

The core of the library is a struct_cast API that generates a parser at compile time. The implementation relies on C++20/23 features like non-type template parameters for strings, concepts for compile-time validation of layouts, and fold expressions to create a monadic pipeline for sequential field processing and error handling. The talk concludes by discussing how upcoming C++26 reflection features could simplify the user-facing syntax with annotations, making this TMP-based approach a stepping stone to future language capabilities. As far as I can tell, the project is not yet production-ready.

C++23 Binary Parsing with Template Metaprogramming

• 0:23 The Problem with Binary Parsing: Manually parsing binary formats in C++ is tedious. Simple reinterpret_cast fails due to padding and alignment issues, forcing developers to write verbose, error-prone boilerplate code for each field. This becomes unmanageable with complex structures like conditional or variable-length fields.
• 8:06 The Chosen Solution: An Embedded DSL: Instead of using an external code generator or macros, the speaker chose to build an embedded Domain-Specific Language (DSL) using C++ Template Metaprogramming (TMP). This allows the parser to be generated entirely at compile time within C++.
• 9:16 Library Goals: The project aims to provide a declarative, macro-free API. Key features include compile-time parser generation, reasonable compile-time and runtime error messages (using std::expected), and support for complex layouts. The central user-facing function is a single struct_cast call.
• 15:11 Core TMP Techniques: The DSL is built on modern C++ features. fixed_string (a C++20 hack) is used to pass string literals as non-type template parameters for field names. type_list and other meta-functions are used to manipulate and validate the structure's layout at compile time.
• 21:36 Defining Layouts: A variadic template, struct_field_list, defines the data layout. C++20 concepts enforce critical constraints, such as ensuring field names are unique and that any field a variable-length member depends on has already been defined ("appears to the left").
• 27:52 The Parsing Mechanism: The struct_cast implementation uses a monadic pipeline built with a fold expression. This reads fields sequentially, and if any read operation fails, it short-circuits and propagates the error. The process is recursive to handle nested structs.
• 38:18 Future-Proofing with C++26 Reflection: The speaker argues that this TMP-heavy approach is a logical precursor to C++26 Static Reflection. With reflection, the cumbersome DSL for defining layouts can be replaced by simple annotations on standard C++ structs, making the user code much cleaner while potentially reusing the underlying TMP generation logic.
• 43:09 Runtime Configuration: In the Q&A, the speaker addresses runtime configurability. He suggests that for formats with multiple versions, the version identifier can be read first, and the layout definition can use a std::variant-like structure to select the correct parser at runtime.