Conference hydra::amiga_v1

	The amiga operating system was written in C, and the 
	RKM manuals as well as most Amiga programing books use
	C for their code examples.  So if you consider C a 
	*GOOD* language, that's probably your best bet.

	There are two suppliers of the C language on the Amiga,
	Manx and Lattice.  The general consensus has been that 
	Manx compiles faster and generates tighter code while
	Lattice does a better job of conforming to standard C.
	You'll find other notes in this conference comparing the
	two.

>	The amiga operating system was written in C

	AmigaDos was written in BCPL which is 'a forerunner of C' (according
	to "The Kickstart guide to the Amiga").

Keith

    even pickier
    
    The 1.3 manual uses the term "AmigaDOS 1.3" to refer to the operating
    system, not just the file system.  I guess they had a tough time
    deciding on a name for it, and wimped out since MS-DOS has gotten
    lots of folks to expect that the OS should be called somethingDOS.
    Hmm... what does the MACintosh call it's OS?
    
    So... the operating system is mostly written in C with some assembler
          the AmigaDOS filesystem was written in BCPL and grafted on
          top of the OS. The new fast filesystem is written in C and assembler?
    
    -Dave
         

    1. Exec
    2. AmigaDOS
    3. Intuition
    
    Anyway, on the original request, on compilers, I'd go with Lattice C, I
    don't know quite why, since I can't seem t get the hang of it on a 512K
    dual floppy A1000, but its the ubiquitous Amiga C language system.  For
    other languages, am only familiar with Multi-Forth from Creative
    Solutions; great support, inexpensive ($79), this also exists on the
    Mac. 
    
    Generally, for program development, get a hard disk and some more
    ram.
    
    Good luck.
    
    John

    Personally, I'd go with Manx C (just to give the counter point :-) ).
    I haven't read the discussion here comparing the two, but my friend
    works with a "certified" (for lack of a better term) Amiga Developer
    who contacted people inside EA who said they chose Manx.  I don't have
    first-hand knowledge of Lattice but Manx is good and should be workable
    on what ever system you have.  {provious to yesterday I was running it
    on a 1Mb A500 with 1 Floppy, but I agree a harddrive is the way to go
    for serious development {got mine yesterday!}}.
    
    George
    

         I can't comment, because I just started using Lattice 5.0,
    and I've never used Manx.  If you look through MSBIS::AMIGA_USENET
    for comparisons you will find that the majority of people
    say great things about Lattice 5.0, and are a little disapointed
    with some of Manx's quirks.  This coming from *major* Amiga people
    - Dave Haynie, Dale Luck, etc...        
    
         If you can wait for the next release of Manx, the
    opinion may just sway again. 
    
    Steve ( now with a HardFrame+ST277N, and compiling is FAST! :^)

Re: .0

Since you asked about non-C languages, I'll give the rundown as I remember:

Pascal -	The only Pascal for the Amiga is produced from MetaComCo.
		Version one of that compiler was terrible, and universally
		trashed by everyone who came in contact with it.  It did
		not compile all of the language constructs you would expect
		from a modern Pascal compiler, and it could not interface
		to Amiga ROM kernal routines.   Version 2 is out, and the
		small number of people willing to try it say it is reasonably
		good.  I have no first hand information about either version.

Modula 2 -	There are at least three Modula 2 compilers.  Two are good;
		one is bad.  TDI is the bad compiler: it lacks some of the
		programming environment of the other two; it has been claimed
		to be buggy; and the company that "supports" it has pulled
		some dirty tricks (sending upgrade announcements and accepting
		money for the upgrade over 9 months before the upgrade was
		written!).  The two remaining compilers seem to both have
		happy customers.  Of the two, Benchmark Modula-2 seems to have
		the most vocal customers.  The other company (based in
		Germany?) also gets praise.  I've only had first hand
		experience with TDI Modula.

Ada -		Not available for almost any personal computer.  It isn't
		available for the Amiga.

Re: C

Manx C produced smaller executables until recently.  This made it the
preferred compiler for developers.

However, in November 1988, Lattice released version 5.0 of their compiler.
This version of the compiler has a global optimizer (a rare feature for
a PC compiler even in the MS/DOS world).  This seems to give Lattice C
an edge for producing small C programs.

The C compiler market is very competitive.  Each release of Manx and Lattice
seems to top the other guy's previous release.  

    Re .*
    
    Thanks for the inputs ; looks like Modula and C are my best bets. If
    anyone has more comments on the Benchmark Modula I'd be interested ;
    particularly from the point of view of array handling and general
    execution efficiency.
    
    Dave. 

I use the BenchMark Modula.  It is a nice compiler, the execution speed of the
compiler and linker are fine, i.e. you don't feel like you are waiting forever
just because I changed one little variable.  I have not done any measurements
of the execution speed.  One problem that I always seem to have is with sets.
They are an inviting feature to use but it always takes me forever to get the
code to work the way I want.  I have a 1Meg A500 with two floppies.  I copy all
my files into RAM:.  This has been fast enough for me.

Talking about serious programming ...
1. I program in C for a living on VAXes and find a symbolic debugger invaluable.  
The Manual says that BenchMark has one, but as far as I know this is vaporware.

2. The second thing is to get some good books on the AMIGA.  The documentation 
on BenchMark is good as a reference manual and they give you 3 disks of examples.
However, it doesn't tell you how to do things.  I have Peck's book 'Programming
the Amiga' and found that very useful.


David

Ps.  Not sure what you wanted to know about array handling.  You just declare
a variable

VAR
  arr : ARRAY [1..10] OF LONG;

BEGIN
  arr[1] := 1;

	Re: Lattice C (V5.xx)

	Anyone have any idea on when Lattice 5.1 might be released?
	I'll be buying when my tax refund comes in, and don't mind waiting
	till late spring if it means a significantly 'cleaner' version.

Don't know when, but it will most likely be Lattice 5.02.

The patches are on their BBS now so they are probably shipping this version.

The shop where you get your's will most likely still have a stock of 5.0.

John

    Re .9
    
    >> Ps.  Not sure what you wanted to know about array handling.  You just declare
    
    Sorry, should've phrased it better... I was wondering about the
    efficiency of use of large arrays ; i.e. how efficiently they're
    packed in memory and handled as parameters. How quickly do you run
    out of memory / stack space ?
    
    I'll look out for the book you mentioned, thanks.
    
    Dave.

    
    As far as I know arrays in C are always passed like pascal VAR
    parameters (ie  A pointer to the actual array is passed.)  So it
    takes the same amount of stack space to pass a really huge array as
    a tiny one.
    
    To be perfectly honest I wouldn't even know how to make C pass an
    array by value.  I'm probably forgetting something simple though...

    regards,
        
    steve mcafee  (Now reachable via TALLIS::MCAFEE)
    
    BTW My vote is for Lattice C, but I haven't used Manx at all.  Lattice
    	really seems to be ANSI standard.  I've got V5.0 and don't have
        any of the patches yet, but I'm still impressed with CodeProbe. 
    	Hard to imagine how Manx's SDB could be any better.  I'm using it
    	for a computer graphics course at WPI this semester and so far
    	things are going well... 

    Thats a good question.  How would you pass an array by value?  
    
    I also like CPR (CodePRobe).  It has saved me *many* hours 
    this week alone.  Although it's not understanding FFP floats  
    threw me off late one night. 
    
    Steve

re. passing arrays by value.

You Can't.  You can pass an *element* by value (or by reference)

  int	x[10];

  foo(x);   	/* pass address of x array */

  foo(x[3]);	/* pass value in x array element 3 */

  foo(&x[3]); 	/* Pass address of array element 3 */.


An array name by itself indicates it's address. It's basically a pointer to
the data type of the array, hence:

	(x+3)   points to array element 3 and
	*(x+3)  is it's contents

John

    
    
    	In K&R, it states that arrays are always passed by reference.
    To pass an array by value each element should be specified.
    
    	It works this way because arrays are just another notation
    for pointers.
    
    		Steve Peters
    

     RE: < Note 2183.16 by ELWOOD::PETERS >
    
>    	It works this way because arrays are just another notation
>    for pointers.

        Not entirely true, in C, a pointer is a variable, while an
     array name is not, so there are some operations which can be
     performed on a pointer, but not an array name.

     for example:

     char  array[10];
     char *point;

       point=array;
       point++;      /* is legal     */
       array++;      /* is not legal */


     Bill Powers

       
         

    If you have a compiler that supports the proposed ANSI standard C,
    arrays can be passed by value by embedding them in a struct and passing
    the struct by value.  Don't do this without a good reason.
    
    
    				-- edp 

Re: .?

I talked to Lattice on the Phone yesterday.  They said that they had
just started shipping free upgrades to all registered owners that morning.
So V5.0 owners,  expect Lattice C 5.02 to appear in a week or two.

If you are thinking about Lattice C, go ahead a buy V5.0.  That compiler
is not so buggy you can't use it, and Lattice will send you the free
upgrade within a couple of weeks of getting your registration card.

Re .13

>    To be perfectly honest I wouldn't even know how to make C pass an
>    array by value.  I'm probably forgetting something simple though...

No, you aren't.  About the best you can do is make the array the single
member of a struct, and pass the struct by value.  Arrays and pointers
are too tightly tied together in C to allow arrays as first class objects.