Re: Standard Ada Preprocessor

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

Marin David Condic wrote:

> I'm not talking about addresses. Have you never seen a rep clause on a 
> record, for example, that a given compiler will refuse to accept even if 
> it is syntactically legal? I don't happen to have one sitting in my back 
> pocket at the moment, but I *know* I've coded up valid rep clauses on 
> records that compilers have spit out and refused to accept. Technically, 
> it is legal for an implementation to refuse just about any rep clause it 
> doesn't want to be bothered with - so perhaps you've got it coded up one 
> way for one compiler and another way for another compiler.
> 
> Perhaps there's some arcane trick that can be pulled to change rep 
> clauses on a record on the fly, but I've not seen it (and it sure starts 
> sounding *far* more complex than decrypting a simple conditional 
> compilation directive - maybe this is what frustrates me about the 
> opposition to a conditional compile: Everyone holds out some cumbersome, 
> complex, arcane trickery that is orders of magnitude more difficult to 
> understand and utilize properly as an answer in order to avoid something 
> that is capable of being pretty simple & basic.). What I *have* seen is 
> rep clauses that a compiler refuses to accept - and hence I can't even 
> *get* to runtime because I've got compile errors. Legal or not - Moral 
> or not - I still have to get a job done and a conditonal compilation 
> directive of some sort would fix the problem.

Sigh, if you want to win the debate, fine, but I can't help you.  If you 
want to have an easier time of it when writing implementation dependent 
code, pay attention.

My point is not that I have a magic wand that can be waved over your 
program to reduce the amount of implementation code to zero.  My point 
is that if you are willing to do things the Ada way instead of the C 
way, the number of system dependent files becomes very small.

It would be nice if you could write your code so that all of the that 
code depended on System, so you didn't need to maintain multiple 
versions.  To some extent that is a bug in the language that we 
discussed in this thread.  (Implementations where System.Name is 
useless.)  What I am trying to say, is use these techniques, and you 
will end up with one or two files that need to be changed when porting.

If you want to use a preprocessor to maintain that file, fine.  Many Ada 
compilers actually supply one, or you can use cpp.  Personally my style 
is to provide a "generic" version and to expect those who port the code 
to tailor it.  Optimally, that file contains only a package body, but 
doing that requires going to extremes you might not like.  Just to give 
one example,  You might define two interfaces for some OS calls and 
choose which one to use every time the interface is called.  This 
requires that the code that calls them, and the parameters passed, are 
in a nested scope.  This often adds extra overhead to system calls. 
Worth it?  You choose.  But putting all the system dependent cruft in 
one compilation unit in my experience, should be automatic.

-- 
                                           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