The new emerging NLE for GNU/Linux

this page accounts for some problematic areas, sketchy solutions, nonportable hacks, terrorism and other misdemeanour


Binding Placeholders

The standard allows function objects to be partially closed; this is achieved by marking the remaining, unbound arguments in the call to std::bind with some special marker elements, the “argument placeholders”. These are predefined within the standard library as std::placeholders::_1 and consecutive, while the type of these objects remains unspecified as by the standard. But unfortunately we need some augmentation on top of std::bind to help with generic partial application of functions, i.e. we need to close systematically a sequence of arguments, both starting from the front or from the back of the argument list. We need this, because it is a standard functional programming technique. Consequently our helper (function-closure.hpp) will build placeholders on its own, and it needs to feed placeholder types to the generated binders.

Thus we rely on the fact, that the gnu standard library implementation has a templated type std::_Placeholder<i>

Size of standard library facilities

Sometimes we need to know the size of an STL or Boost class, but can’t afford to include the header and just write a sizeof(). Because including some of those headers incurs quite some price in terms of compilation time and even size of the debug executable.

Obviously, a simple solution would be to measure those sizes and hardcode them. But what about portability? To get out of that dilemma, I created a traits class which mimics the implementation memory layout of those facilities in question, simplified as much as possible. As long as the GNU libstdc++ or Boost don’t change their implementation layout, this give us precise and fast size bounds.

When relying on that hack, we should make sure always to place some kind of static_assert into the corresponding implementation files to ensure the real facilites actually do fit into the guessed storage dimensions.