dcl | Elegant minimalistic implementation of OOP with mixins | Dependency Injection library

In this loop, if KeyPressed is not equal to EnterKey when the loop starts, *in03 will remain *off forever. I'm guessing you need another EXFMT inside the loop.

The root of your question seems to be the difference between decltype(X::i) and decltype((X::i)). Why does (X::i) yield a int&? See:

https://timsong-cpp.github.io/cppwp/n4861/dcl.type.decltype#1.5

otherwise, if E is an lvalue, decltype(E) is T&, where T is the type of E;

However, the key point here is that the fact that it yields a T& doesn't really matter:

https://timsong-cpp.github.io/cppwp/n4861/expr.type#1

If an expression initially has the type “reference to T” ([dcl.ref], [dcl.init.ref]), the type is adjusted to T prior to any further analysis. The expression designates the object or function denoted by the reference, and the expression is an lvalue or an xvalue, depending on the expression. [ Note: Before the lifetime of the reference has started or after it has ended, the behavior is undefined (see [basic.life]). — end note ]

What "justifies" it then? Well, when doing decltype(X::i) we're concerned primarily with what the type of X::i is and not its value category or its properties when treated as an expression. However, (X::i) is there if we do care.

You have some contradicting requirements between your comment:

I need number of rows inserted in single statement limit

and your question:

rate-limiting specific connection / session / execution attempting insert of more than 1 row per 5-10 seconds

The "rate limit" can't be done without external tools, but the "in single statement limit" part can be achieved with a statement level trigger.

The function checks for the number of rows inserted:

The behavior of [[no_unique_address]] is always at the discretion of the compiler; it is never required to do anything. A compiler can ignore it in all cases, respect it in some and ignore it in others, or respect it all the time. So long as the compiler is not doing it at random (ie: it's consistent), it can do whatever it wants (within the other rules of layout).

So why does it work in one case and not the other? Because that's how the compiler vendor implemented it.

If you want to take the best advantage of it, make things easiest for the compiler to handle. Don't use the same empty type multiple times (this limits what compilers can do). Declare all of the empty fields first.

Alternatively, you'll have to track down the ABI rules your compiler is using. The Itanium ABI used on Linux has particular provisions for no_unique_address.

The problem is the - in your keywords, but you can tell your new language to treat it like a normal letter:

You do seem to be setting the variable type1 inside your (c:nest2), and you do call (c:txcm_block) from (c:nest2), but (c:txcm_block) declares type1 as its local variable, so type1 is set to NIL on entry to (c:txcm_block).

NIL is not a string, so strcat naturally complains and bails.

Remove type1 from the local variables declaration list in (c:txcm_block) and put it on the local variables declaration list in (c:nest2).

In general, to deal with such situations, use your debugger to "break on error", then inspect the execution trace and check the current values of the variables of interest (like type1) at that point.

Use an immediately invoked initializing lambda:

By the plain wording of [except.ctor]/3, it applies to objects with any storage duration, as long as they are subobjects of an object whose construction was terminated by an exception. This should not be controversial.

However, the wording of [except.ctor] has changed over time, and this seems to have created some issues which the OP has noticed. The background is that the wording used to be simliar to the current wording, with "stack unwinding" only referring to the destruction of automatic objects, and someone noticed that this created an inconsistency, where, when no matching handler is found, it is not guaranteed whether stack unwinding occurs, but it is guaranteed that subobject destruction occurs (since there is nothing in the text to say that it may not happen if a handler is not found). This was CWG 1774. CWG agreed that this inconsistency was undesirable (and perhaps it was unintentional, though that page doesn't say). So the wording was changed so that subobject destruction would be an aspect of "stack unwinding", and thus covered under [except.handle]/9, instead of being a separate process. But then later, to resolve a different DR that has nothing to do with exceptions, the old wording was added back, and I'm 90% sure that it was unintentional. The intent of the resolution to CWG2256 was just to avoid discrimination against trivially destructible objects, and not to actually change anything about exception handling.

Therefore, the current wording is defective, and the standard should still be read as if "stack unwinding" includes subobject destruction (i.e., the resolution to CWG 1774 stands). You might even be able to fix this editorially (i.e., submit a pull request against the standard source).

Scoped enums always have fixed underlying type. [dcl.enum]/5 (C++17):

For a scoped enumeration type, the underlying type is int if it is not explicitly specified. In both of these cases, the underlying type is said to be fixed.

So your E has fixed underlying type of int. Then in paragraph 8:

For an enumeration whose underlying type is fixed, the values of the enumeration are the values of the underlying type.

2 is in range for int, so by the text you quoted from [expr.static.cast], the behaviour of the cast is well-defined.