Member functions with access to local variables

[Linden Krouse]

I suppose my initial example wasn't the greatest. Here's a better 
example of what I'm trying to do.

module a;
class A : SuperA
{
     B b = new B();
     C c;
     D d;
     //...

     this()
     {
         b.loadInteralStuff("filepathofstufftoload");
     }

     void doStuff()
     {
         int var1, var2;
         char var3;
         int[] var4;
         File var5;

         //read and parse stuff from a file...

         //found commands that need to be executed, although
         //this class only knows that they are a set of commands
         //not what they actually do (and shouldn't)
         b.executeCammands(commandArray);
     }

}

module b;
class B : SuperB
{
     SomeComplexDataStructure data;

     //private helper functions

     void loadInternalStuff(string filename)
     {
         //load a file in a certain way. This implementation
         //could be subject to change which shouldn't affect A
     }
     void executeCammands(byte[] commands)
     {
         //execute each command, most of which need to edit
         //the local variables of doStuff() but should be
         //implemented in this class

         //in most cases, the local variables needed could be
         //similar to any implementation but are different enough
         //for it to be a major annoyance to pass every possible
         //variable needed to this function by reference
     }
}

It would be convenient to have a way to either specify that a 
function can be called only by a specific function and have 
access to it's local variables or overload a function to provide 
a specific implementation for certain functions.