I've decided where I'm going to go with this. 

The pre-existing function, 'alloca', allocates memory until the end of the function (not until the end of the current scope).

So I will create a new function, 'classalloca', which will not just allocate stack memory but also invoke a constructor.

The GNU compiler gives a function a quick scan before it compiles it. It looks for things like the use of 'alloca', and it enforces the use of a frame pointer if 'alloca' is used at all.

Similarly, if my new function, 'classalloca', is used at least once, then the function will be given a hidden local variable, which will be a linked list for destructors that need to be called.

When the function is exited, either by a 'return' or a 'throw', the linked list of destructor pointers will be traversed and invoked.

After I have 'classalloca' working perfectly, I'll then implement the unary '%' operator, which will pretty much be short-hand for 'classalloca', meaning we'll be able to do:

for (unsigned i = 0; i < N; ++i)

    for (unsigned j = 0; j < M; ++j)

        %async(Func);

So in the above snippet, we'll have N*M concurrent threads. And if we only want M concurrent threads, we can do:

for (unsigned i = 0; i < N; ++i)

    [&]()

    {

      for (unsigned j = 0; j < M; ++j)

          %async(Func);

    }();

The above lambda is of course a bonafide function, and so the objects created by 'classalloca' will be destroyed when the lambda returns. This means we'll get M concurrent threads.

This will be fun to implement.

By the way I've discarded the idea of using multiple percentage signs such as %% or %%%. Instead you'll have to use lambdas for finer control.