Re: Tricks Of The Trade: How To Compile Large Program On Two Very Different Compilers

[Georg Bauhaus <rm.dash-bauhaus@futureapps.de>]

ChristopherL schrieb:
> Does Ada have anything similar to the following C preprocessor
> directives:
> 
> #ifdef TABLE_SIZE
> --Add Code Here
> #elif TABLE_SIZE < 50
> --Add Code Here
> #endif
> 

I had hesitated to mention a preprocessor.  You can use
M4, or cpp.  However, dead code elimination is another
option, stays within the language and insofar seems more
manageable (cases don't get lost accross units
when they are in types, not #conditionals, for example.)

(To seems more manageable to me at least, I have lost hair
in missing #else, missing code, missing test cases, and
similar features of conditional program text.
The separate directories solution (as long as the number
of decisions is small) is no less checkable, and, I think,
no more prone to errors than placing the code between
preprocessor conditionals.)

Small example that reduces the need for conditional
text to one constant.  It can be replaced using
a preprocessor (or script or human) that needs not
support conditionals.  Dead code elimination may work:

package Control is

   type Capacity is range 1 .. 8_000;

   type Table_Size is (Small, Big);
   for Table_Size use (Small => 10, Big => 1000);
   for Table_Size'Size use Capacity'Size;

   Mode : constant Table_Size := Small;  -- <- adjust per system




   procedure Start;

end Control;

with Interfaces;
with Ada.Unchecked_Conversion;
package body Control  is

   function To_Capacity is new Ada.Unchecked_Conversion
     (Table_Size, Capacity);

   package Small_System is
      procedure Run;
   private
      Last : constant Capacity := To_Capacity (Small);
      Data_Store : array (Capacity range 1 .. Last) of Interfaces.Unsigned_8;
   end Small_System;

   package Big_System is
      procedure Run;
   private
      Last : constant Capacity := To_Capacity (Big);
      Data_Store : array (Capacity range 1 .. Last) of Interfaces.Unsigned_8;
      -- ... other differences
   end Big_System;


   procedure Start is
   begin
      case Mode is
         when Small =>
             Small_System.Run;
         when Big =>
            Big_System.Run;
      end case;
   end;

   package body Small_System is separate;
   package body Big_System is separate;
end Control;