Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Path: utzoo!mnetor!uunet!husc6!mit-eddie!ll-xn!ames!ucbcad!ucbvax!jade!eris!mwm
From: mwm@eris.BERKELEY.EDU (Mike (My watch has windows) Meyer)
Newsgroups: comp.sys.amiga
Subject: Re: Request for Compiler Info
Message-ID: <5540@jade.BERKELEY.EDU>
Date: Tue, 20-Oct-87 22:38:33 EDT
Article-I.D.: jade.5540
Posted: Tue Oct 20 22:38:33 1987
Date-Received: Thu, 22-Oct-87 06:55:55 EDT
References: <4443@zen.berkeley.edu> <31235@sun.uucp>
Sender: usenet@jade.BERKELEY.EDU
Reply-To: mwm@eris.BERKELEY.EDU (Mike (My watch has windows) Meyer)
Organization: Missionaria Phonibalonica
Lines: 169

In article <31235@sun.uucp> cmcmanis@sun.UUCP (Chuck McManis) writes:
<In article <4443@zen.berkeley.edu> (Jonathan Dubman) writes:
<>Having gained little from the objective reviews ("Both are good systems...")
<>I am interested in religious statements from any owners of MANX and Lattice,
<>especially from those who have seen Lattice 4.0 in action.  Unless the flame
<>is low, please mail such statements PRIVATELY. 
<
<[Minimal flamage here, just the facts ]
<
<I own Lattice, (thats what I started with), have nothing but hearsay to report
<on 4.0 although they should get my Update card today so I expect my copy RSN.

Ditto.

<The bottom line : 
<
<    Manx is an excellent compiler for those who know C really well.
<
<    Lattice is an excellent compiler for those who tend to make typos or
<    don't know C as well, by virtue of its extensive diagnostics. If you
<    make the statement "If I had wanted to Lint my program, I would have 
<    run Lint!" then you probably want Manx.

Well put. If you never make mistakes, then Lattice doesn't have any
advantages - or very few.

However, it should be noted that Lattice follows the Unix compilers in
reporting errors: filename, line #, error message all on one line.
Manx outputs the source line, then a line with an "^" to indicate the
character it was parsing when it found the error, then the message.
Iterate the last two for lines with multiple errors.

Since I found it getting the line # wrong in ~ 50% of the cases (hard
to avoid in recursive descent compilers), this seemed to me more like
a waste of precious screen space than anything useful.

<>	-What are the classes of source code incompatibility?

Avoiding odd practices, it boils down to three:

1) What in the set of dpANS - K&R features has been implemented.
2) ATT or BSD library calls.
3) 32 vs. 16 bit ints.

With the next release of each compiler (Manx 3.6(?) and Lattice 4.0), most
of those should vanish. 3) Manx already supports both 16 and 32 bit ints,
Lattice 4.0 will support both. 2) dpANS is going with ATT library
calls, + some extras. Lattice 3.10 follows those, and Manx is supposed
to be going that way. For now, Manx has BSD library calls. 1) The ones
that were in v7 c are in both. The ones in current Unix pcc
are in both. Lattice supports prototyping, Manx is supposed to in the
near future.

Of course, if you play games with the Manx pre-compiled .h files
(Lattice 4.0 has those), you can get into all kinds of trouble.

<>	-Size of code? Speed of compilation? 
<Manx wins.

Uh, Lattice wins for .o files, Manx for the final executeable. Lattice
does a lot more work for you in the libraries. Manx is noticably
faster (Manx 3.4a vs Lattice 3.10).

<>	 Provisions for LARGE programs?

As Matt pointed out elsewhere, if a 68K C compiler has problems with
large code or data segments, you've got a badly broken compiler.

On the other hand, if you mean working with programs with lots of
source - enough to want to scatter it into multiple directories - then
I think Lattice wins. Lattice follows the Unix compilers in putting
the .o for a file in the current directory, even if the source is
elsewhere. Manx will put the .o in the same directory as the source.
This means my Unix habits don't work. The difference in error message
formats also causes some problems with large programs.

<>	 (i.e. Make utility included, etc.)
<
<Manx comes with make, Lattice doesn't. I use the one on one of the
<Fish disks. 

Doesn't the high-end lattice package come with a Make? Since most of
the utilities in that package are available PA, and the cost of the
rest is less than the cost difference of the package, it doesn't make
much sense.

<>  	Scatter-loading?  Overlays?
<

Scatter-loading is done by the DOS loader. You can turn it off to get
smaller binaries and faster startup time. Manx may produce binaries
in the "no scatter-load" format, but it'd surprise me.

Overlays can be done with the stock metacomco linker (alink). It can
be used instead of the linker supplied by lattice (blink), though the
4.0 blink overlays.

Theoretically, you ought to be able to compile code with Manx, convert
it's .o files to AmigaDOS style .o files, then blink them to get
scatter loading and overlays. Someone who uses Manx regularly want to
comment?

<Yes on both counts. In 4.0 Lattice claims to have a totally compatible 
<Assembler (can use the C/A .i files). 
<
<>	-How about the documentation?  (Great flame category.)
<
<Both do really well here. 

I disagree with Chuck. The Lattice manuals are excellent, but the Manx
manuals have problems. Then again, I didn't have original docs, I had
docs that had been through several levels of upgrade.  Problems:

	The upgrades weren't page replacements, they were addenda to the
	manual section. This means you have to check the manual & each
	addenda to use it as a reference manual.

	The manual disagreed with itself in at least one place.

	The function index was broken into parts depending on where
	the function came from. Not a bad idea, but the Lattice tehnic
	of having all functions in a single area (with an index, of
	course), and labelling each function as to where it came from
	(ANSI, Lattice or Amiga) works much better.

Chuck, which manual set do you have? Hopefully, Manx improved there
manuals as much between 3.0 and 3.4 as Lattice did between 3.02 and
3.10. Likewise, does the Manx upgrade include a new manual (Lattice
did, which was a good thing).

Of course, the function index is only of minor importance. I avoid the
Lattice functions, and use the RKM/autodocs/RAP for the Amiga
functions. The ANSI stuff I know by heart :-). The important part of
the manual is the discussion of how the compiler parts work. Manx has
an excellent tutorial, and mediocre reference. Lattice has a good
tutorial and reference. Hard to say which is better, except for the
(*&*^ addenda in the Manx manual.

The one thing you didn't ask about was bugs. There are far more bug
reports about Manx than about Lattice on the net. There are more bug
reports about Manx on the net than there are about Lattice on the
Lattice support BBS! My experience with Manx has been that it's a
buggier compiler (I've tripped over about 5 Lattice bugs, each in a
different program, in 21 months. I've tripped over 3 Manx bugs, all in
one program, in 1 month).

There's also the question of support. Lattice does very well, with a
BBS with 9600 baud modems available to registered users. The one time
I found a serious bug, I called in to report it only to find the patch
on the BBS. They are also good about admitting "whoops, we made a
mistake" on some features, and providing patches to fix them.

Someone wanna comment on how Manx does in this area?

Anyways, I think the free market is working it's magic, and the two
companies are making sure their next release is better than the
competitions last release. The result is that the best compiler is the
last one to release a new version. The remaining differences qualify
as "religious."

The one thing I do wish for is that some of the low-cost IBM-PC
compiler people would produce an Amiga compiler!

	<mike
--
It's been a hard day's night,				Mike Meyer
And I been working like a dog.				mwm@berkeley.edu
It's been a hard day's night,				ucbvax!mwm
I should be sleeping like a log.			mwm@ucbjade.BITNET