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

[Niklas Holsti <niklas.holsti@tidorum.invalid>]

ChristopherL wrote:
> On Nov 4, 10:53 am, ChristopherL <clusard...@aol.com> wrote:
>> Hello,
>>
>> In about a year, I will be presented with the task of making the same
>> large program compilable with two very different Ada compilers.
>>
>> Sorry, I do not know the names of the compilers or computers that I'll
>> be working with. The decision has not been reached at this time. The
>> manufacturer support on one or both of these compilers may be almost
>> non-existant.
>>
>> How would you go about compiling your code?
>>
>> Thanks
> 
> O'kay, I have some additional information to add!
> 
> I will know what files to use to compile with each compiler. In other
> words, I will be told this program (group of files) compiles on this
> computer using this compiler, and I will be told the same thing for
> the second compiler/computer. Again, they will be compiling the same
> program with minor differences between them. The differences are in
> about 30 files. So, basically there are two groups of 30 files. Each
> compiler will use the program with different a different set of 30
> files.
> There are about 1000 files in the entire program. So compiler A will
> compile 1030 files and compiler B will compile 1000 files plus
> different 30 files. The 30 files are required to compile with compiler
> A, and a different set of 30 files are required to compile the 1000
> files with compiler B.

You are still not making your question or problem clear, in Ada terms. 
To get reasonable answers you should explain what all these "files" have 
to do with the desired functionality of the program on one or another 
computer.

So you have a computer A with compiler A, and a computer B with compiler 
B. The Ada program consists of 1000 "files" (presumably Ada package 
declarations and package bodies) that are the same for system A and for 
system B. The complete program for system A consists of these 1000 
shared files, plus 30 files specific to system A. The complete program 
for system B consists of the same 1000 shared files, and 30 other files 
specific to system B. The core question is *why* you have 30 different 
files for systems A and B:

- Are they simply different versions of the same Ada packages, one 
version tailored for system A, the other for system B, but implementing 
the same functionality? Tailoring could be necessary for compiler 
differences, O/S differences, or computer differences.

- Or do they represent different functionality, so that the complete 
program on system A behaves differently from the complete program on 
system B? For example, the program on system A may have some added 
functionality that is absent from the program on system B, and vice 
versa. Do you now want to combine the two so that all functionality 
exists on both systems?

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
       .      @       .