#Amiga Dev in general
3 messages in this thread
Steve:
I never heard that before. My impression was that most compilers,
including the Unix C compiler, first converted C source to Asm source.
I read several times that Lattice compiled to a "proprietary" quad file.
Whether that meant "proprietary" to Lattice, or "proprietary" to Commodore
was never revealed. In either event, it implied to me that the Lattice
compiler output is not what could be called, "universal", although it may
be termed, "official", as you pointed out. I never knew you could do much
with it, other than link and run it. With the Aztec, you can study it and
even massage it before proceeding, if desired.
Aztec assembler "quirks" result from the switches used. You can have it
compile Metacomco assembly if you want it to. It is very agile. According
to certain magazine articles, some writers use it as their only assembler.
Our correspondent wanted to write games. He already owns the Lattice,
so my argument is moot. My point was only that if he had the Aztec, he
could have massaged his compiler output, had he wanted, so adaptable is it.
I speak from an amateur's experience in using both compilers when I say
that what IS important to the student of games and hacks is the fact that
the vast bulk of available example code, from Schwab, Ozer, Dillon and half
dozen others will be found written with AZTEC alone. That, in fact, is
precisely the reason I acquired one. I can tick off a couple features
exclusive to Aztec which the user is free to use or ignore, one of which
makes 99% of all source code around here compile a darned sight smaller and
execute a tad quicker.
Regards Tom
Lattice uses a 'quad' file between compiler passes (I assume this is their
intermediate language), but the final result is a BLink-compatable object
module. This is the 'official' Amiga object module format. However, every
major library vendor that I'm aware of supplies libraries/object modules
commercially in _both_ formats, for both compilers. Thus, 99% of the time
the object format used is a moot point. The fact is, for just about
everybody it doesn't make a lick of difference what the obj format is, as
long as it all links into a proper executable.
A major plus regarding compiling into assembly code is in finding bugs.
Every compiler has them, and being able to look at the assembly code w/
intermixed C code (as comments) is alot better than trying to disassemble
an object module.
-Mike
If you are trying to track down a (suspected) code generation bug in
Lattice, CPR has a very nice mixed mode which displays the C source code
and the disassembled executable. This has always been quite sufficient for
me. I find little value in compiling to assembler and then modifying the
assembly code. That is about as poor a programming practice as I can
imagine. A properly written modular design will allow you to convert
critical routines to assembly code in an orderly fashion without the risk
of nasty bugs and non-maintainable code.
— Mike Roth