Intelligent Scope Hierarchy

Stretto uiy12345 at gmail.com
Thu Oct 31 12:05:01 PDT 2013


Hi, I'm new to D and stumbled on the new allocators thread. In
the help there is code like

      auto buffer = Mallocator.it.allocate(1024 * 1024 * 4);
      scope(exit) Mallocator.it.deallocate(buffer);

which seems redundant and error prone.

Would it not be possible for allocate to automatically add itself
to the parent scope by default?

This way code like

      auto buffer = Mallocator.it.allocate(1024 * 1024 * 4);

would automatically expand to

      auto buffer = Mallocator.it.allocate(1024 * 1024 * 4);
      scope(exit) Mallocator.it.deallocate(buffer);

If, say, we needed to "raise" the scope(exit) of allocate to act
on the parent of the parent scope then we could do something like

      auto MyAllocate(size)
      {
          return scope(raise) { Mallocator.it.allocate(size); };
          auto scope(parent) { print("Happy times"); };
      }

      auto buffer = MyAllocate(1024 * 1024 * 4);

So that allocate inside MyAllocate won't release the buffer on
the return of MyAllocate on use scope.

with scope hierarchy the above would translate into

      auto buffer = MyAllocate(1024 * 1024 * 4);
      Mallocator.it.deallocate(buffer);
      print("Happy times");

This will allow wrapping automatic scope exits to behave properly.

Of course with such a feature one would also need to prevent
automatic scope assignment:

      auto buffer = scope(none) MyAllocate(1024 * 1024 * 4);

would prevent any auto scope from My Allocate and subcalls from
being called.


This is just a rough suggestion that hopefully will lead to more
potent scope control and less error prone allocators. I believe
it should be somewhat easily implemented by having some type of
vtable like control for each function that is called after each
function to deal with the scope chaining.






More information about the Digitalmars-d-learn mailing list