Re: Too big

[rieachus@comcast.net]

 
> What is the most likely reason? For example, the offending subunit contains a large number of "separate" procedures. Would it help to wrap them up in a package?
ther than heuristic methods
> 
> All sensible suggestions welcom

GNAT tends to insert separate units where they belong during compilation.  In other words, separate may be of use to you in organizing your program code, but the compiler never actually sees the unit as separate.

However, if you reuse separate unit names, when the compiler tries to merge the text, you can end up with an infinitely long source file.  Sounds like what is happening to you.

If you just cut and paste to remove separate units until it works, fine.  However, I suspect that you have a more subtle problem in that you are using separate units where you really should be using generics.  There is a sort of "Aha!" moment when you realize that generic instantiation in theory happens at execution time.  (In other words, the generic is instantiated--the formal generic parameters are replaced by the actual (generic) parameters, then the code is called as usual. Ada always goes through this two-step at execution time.  Most of the time one or the other--elaboration or calling--does most of the work, but they are always both done and in order.) The compiler may make several different code objects (at compile time) for a generic unit, and in some cases the correct unit will be selected during execution.

Sounds complex, but it really isn't.  A short example should help:

generic
  type Element is private;
  type My_Array is array (Integer) of Element;
function Reverse(MA: My_Array) is
  Temp: My_Array := MA;
  for I in 1..MA'length loop -- The array bounds here might be say, 11..19.
    Temp(MA'last-I+1) := MA(I);
  end loop;
  return Temp;
end Reverse;

When you say:  function Reverse_String is new Reverse(Character, String);
you get a regular function.  Junk: String := Reverse(Some_string);  Is then a normal call.

Why all this fancy stuff?  The two stages can be a natural separation of roles, and saves you from creating (sometimes) hundreds of busy little operations which you have to keep straight.  I suspect that this gives you the (source) readability you were trying to get with separate.

I think I got all that right.