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

[Marin David Condic <nobody@noplace.com>]

That works for some things, but it still will barf when a statement is 
compileable for one target but not for another. I'm thinking of a case 
where (for example) you can get one size of float for one target, but 
for another target that size is not allowed. Hiding it in a 
discriminated record isn't going to help if the compiler pukes all over 
the alternative you're not going to use. Perhaps the compiler should be 
smarter - but if I keep waiting for compilers to be smarter, I won't get 
my job done & I'll be forced to resort to C. ;-) If you don't like the 
floating point example ("You ought to be using digits & attributes, you 
fool!" :-) then think "representation clause" and start imagining all 
the target/compiler variations on that.

Its an interesting proposition and might provide some usefulness. 
Certainly there are characteristics that can be toggled at runtime and 
this might be of some help. (Like I said, the runtime stuff I already 
could have handled with my own package.) Its just that usually the point 
where I get hung out to dry is when I can't get something past the 
compiler because it is compiler-dependent or there's something 
platform/target dependent that makes the compiler choke.

MDC


Robert I. Eachus wrote:
> 
> 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.
> 
> 
> 


-- 
======================================================================
Marin David Condic
I work for: http://www.belcan.com/
My project is: http://www.jsf.mil/NSFrames.htm

Send Replies To: m   o   d   c @ a   m   o   g
                    c   n   i       c   .   r

     "Face it ladies, its not the dress that makes you look fat.
     Its the FAT that makes you look fat."

         --  Al Bundy

======================================================================