Re: Standard Ada Preprocessor (Was: why ada is so unpopular ?)

["Robert I. Eachus" <rieachus@comcast.net>]

Marin David Condic wrote:

> Perhaps a pragma that took some constant string and compared it to a 
> string literal and compiled the associated code only if equal would be 
> sufficient. I could build my "package Configuration" and have something 
> like
> 
> pragma If_Equal (Configuration.OS => "TOPS 10",
> <some collection of Ada code - declarative or executable>) ;
> 
> It would be a cheap fix that minimizes the impact to any existing 
> packages or code and only requires compile-time interpretation of a 
> pragma - something compilers already do.

Today you can write code that says:

if Configuration.OS = "TOPS 10"
then
   <some collection of executable Ada code>
else
   <some other collection of excutable Ada code>
end if;

And your compiler should eliminate the code not executed if 
Configuration.OS is a static string constant.  That is available now.

What about declarations?  Then you have two choices.  The first is 
variant parts:

type Foo(Choice: Boolean) is record
   case Choice is
     when True =>
        Tops_10_Component: Float;
     when False =>
         ...
   end case;
end record;

Or you can do:

if Configuration.OS = "TOPS 10"
then
   declare
      Tops_10_Only: Integer := ...;
   begin
      <some collection of executable Ada code>
   end;
else
   declare
      Some_Other_Declaration: Some_Record_Type;
   begin
      <some other collection of excutable Ada code>
   end;
end if;

Also you can make a static Boolean constant:

Tops_10: constant Boolean := Configuration.OS = TOPS 10";

If you want or need to, I usually do.   Oh, one other neat trick.  Look 
at Foo above.  When creating all those objects of type Foo, you don't 
want to have to remember to specify the correct constraint.  So just say:

subtype Foob is Foo(Tops_10);

If you forget and declare an object of type Foo, the compiler will tell 
you.  (Unless of course you give it an initial value, but then you don't 
really have a bug anyway, since the value has the right discriminant.)

If you are generating decent floating point code for x86 processors 
right now you can end up with a LARGE enumeration type and case 
statements. (Actually, combining the cases so the right one is available 
on each system is a non-trivial exercise.  And once I get it working, I 
often leave the intended static constants as variables and set them at 
install-time or run-time.  I need that to make testing survivable, so 
why not let people use it that way. ;-)

So right now, these features are a usable part of the language.  Not 
heavily used, but they can be.  Which is why I think that "fixing" 
System and explaining why would be a big help.



-- 
                                           Robert I. Eachus

"The war on terror is a different kind of war, waged capture by capture, 
cell by cell, and victory by victory. Our security is assured by our 
perseverance and by our sure belief in the success of liberty." -- 
George W. Bush