[net.micro.mac] true code-generating M2 for the Mac ?

hvt@tnocsda.UUCP (07/11/86)

Double Click !

Is there a true 68000 code-generating (as opposed to p-code) 
Modula-2 compiler forthe Mac ?

Thanks in advance for any help/pointers.

 - Henk Vantyen
   mcvax!tnocsda!hvt

baron@runx.UUCP (07/19/86)

> Is there a true 68000 code-generating (as opposed to p-code) 
> Modula-2 compiler forthe Mac ?

As far as Modula-2 products go, there are no native code generating Modula-2
compilers available. They all produce M-code.


/* Jason Haines            ACSnet: baron@runx
 * ElecEng Undergraduate   CSNET:  baron@runx.oz
 * Australia               ARPA:   baron%runx.oz@seismo.css.gov
 * 
 * UUCP:
 *   {enea,hplabs,mcvax,prlb2,seismo,ubc-vision,ukc}!munnari!runx.oz!baron
 */

darryl@ism780c.UUCP (Darryl Richman) (07/21/86)

In article <1392@runx.OZ> baron@runx.OZ (Jason Haines) writes:
>> Is there a true 68000 code-generating (as opposed to p-code) 
>> Modula-2 compiler forthe Mac ?
>As far as Modula-2 products go, there are no native code generating Modula-2
>compilers available. They all produce M-code.

This is simply not true.  MacMeth from Modula Corp. generates native code,
and VERY swiftly.  It cannot be used to produce desk accessories, and it
has a strange method for generating double clickable applications.  It was
written by Wirth's group in Switzerland for their Lilleth computer, and,
unfortunately, attempts to use the Mac as if it were a Lilleth.

	    --Darryl Richman, INTERACTIVE Systems Corp.
	    ...!cca!ima!ism780!darryl
	    The views expressed above are my opinions only.

bobc@tikal.UUCP (07/21/86)

In article <1392@runx.OZ> baron@runx.OZ (Jason Haines) writes:
>
>> Is there a true 68000 code-generating (as opposed to p-code) 
>> Modula-2 compiler for the Mac ?
>
>As far as Modula-2 products go, there are no native code generating Modula-2
>compilers available. They all produce M-code.

There are two 68000 code-generating Modula-2 compilers for the Mac.
The first is based on the 5 pass pdp11 compiler (modified to generate
68000 code), the second is the one pass MacMETH system which is sold
by Modula Corp (for ETHZ, which also distributes it).  The 5 pass
compiler is free, and the one pass compiler is 99$ US or 200 sFr
(?Swiss Francs).

MacMETH is a fair system, it does have some implementation problems
that I don't like:

    1)	It does not come with a full mac interface you have to write
	your own.  (This is a pain I know I did it for the 5 pass
	compiler).

    2)	The implementation of the "loader" traps off all the interupts
	to the MacMETH debugger, this makes it impossible to use
	MacsBug, or other debuggers.  This bothers me because when
	attempting the Port the interface to this compiler their where
	mistakes in the interfaces which could have been detected
	correctly with MacsBug that cause the MacMETH debugger to get
	totally lost.
    
    3)	There is not support for Co-routines (however programs can
	load and execute other programs {really modules}).  The only
	support for co-rouitnes in the 5 pass compiler for the Mac is
	what I have done (which has not be distrubuted very far
	because I am very busy right now, and it needs a better test).

    4)	I have reports that using the MacMETH `shell' runs out of
	memory when used in a edit, compile, and run set up.  (ie fix
	a bug, compile module, run module, fix a bug, ... which is all
	done with out returning to the finder).

    5)  The editor is a Lilith editor it does not use dialogs,
	SFGetFile, the scrap, and other neat Mac things.

    6)	The InOut module does not use SFGetFile and SFPutFile (I like
	not having to type the file name correctly as it allows me to
	use fancier file names with out having to worry about miss
	spelling the name)

Having stated some of the bad parts, I will now also say that it is
very cheep, and very fast, and until something new comes out it is the
best that there is.


Bob Campbell
Teltone Corporation		18520 - 66th AVE NE
P.O. Box 657			Seattle, WA 98155
Kirkland, WA 98033

{amc,dataio,fluke,hplsla,sunup,uw-beaver}!tikal!bobc

parent@suvax1.UUCP (07/22/86)

------ Wacka Wacka Wacka ................<>.............

Yes there is a true 68K generating M2 compiler for the mac available from the
Modula Corp.  I believe it's called MacMETH (Macintosh Module From ETH).  Price
is $100 it is (I believe) a single pass compiler with built in editor, linker,
and post-mortem debugger.  I don't think any of the toolbox routines are
implemented but there is an inline procedure if you want to do it yourself.
(Perhaps Bob Cambels routines from the PDS ETHZ Modula would work?)  Hope this
helps.

	/^-^\			Sean R. Parent
	\ " /			Seattle University
	 \-/			(Standard Disclaimer)

------------------------------------------

marchesi@cernvax.UUCP (marchesi) (07/22/86)

In article <1392@runx.OZ> baron@runx.UUCP writes:
>
>> Is there a true 68000 code-generating (as opposed to p-code) 
>> Modula-2 compiler forthe Mac ?
>
>As far as Modula-2 products go, there are no native code generating Modula-2
>compilers available. They all produce M-code.

MacMeth is an implementation of the new one-pass Modula-2 compiler by N.Wirth
for the Macintosh which compiles to native code; it was written at the ETHZ.

We have already ordered it; if there is any interest, I will post a brief
summary once we have received it/played a little with it

Paolo

------------------------------------------------------------------------------
Paolo Petta

p-mail: DD Division
	CERN
	CH-1211 Geneva 23
	Switzerland
e-mail: ...{seismo,philabs,decvax,...}!mcvax!cernvax!marchesi

jnp@daimi.UUCP (J|rgen N|rgaard) (07/22/86)

Hello.

There are (at least) 2 native code generating MODULA-2 compilers for the Mac
One is the "old" 5-pass system
from ETHZ. But right now I'm using their new 1-pass system called
MacMETH (announcement i net.micro.amiga or another amiga group)
It is fast, uses load-time linking, (fast link), and comes with
a fine source-code debugger.
Limitations are code-size at most 32K (pr MODULE, no limitation on maximum size)
"EXPORT QUALIFIED" not implemented yet but exports everything, 
and HFS not recognized, but it works within the directory it is  resides.

UUCP address of the distributor is : ...!mcvax!cernvax!ethz!heiz
(* Werner Heiz *).
Prize is around 200 Swiss francs.



				Regards
				J|rgen N|rgaard
                                e-mail: ....{seismo!}mcvax!diku!daimi!jnp

rmarti@sun.uucp (Bob Marti) (07/26/86)

> 
> > Is there a true 68000 code-generating (as opposed to p-code) 
> > Modula-2 compiler forthe Mac ?
> 
> As far as Modula-2 products go, there are no native code generating Modula-2
> compilers available. They all produce M-code.
> 
> 
> /* Jason Haines            ACSnet: baron@runx
>  * ElecEng Undergraduate   CSNET:  baron@runx.oz
>  * Australia               ARPA:   baron%runx.oz@seismo.css.gov
>  */

I don't know where you got that information from, but I happen to have not
one but TWO different Modula-2 (well almost, see below) compilers generating
68000 code.  Both were produced at ETH in Zurich, Switzerland:

MacLogimo consists of a 5-pass compiler, a linker, and a simple TTY-based
interactive post-mortem debugger.  It has been posted to the net in 13 parts
about a year ago.

MacMETH is a new Modula-2 development system comprising a 1-pass compiler,
an editor, and an interactive source-level debugger, all of which were derived
from the latest Lilith/Ceres Modula-2 software.  Unfortunately, the compiler
is non-standard in that it does not allow type-transfer functions of the form
y := T(x) where y is a variable of type T.  Instead, you have to use the
function VAL which has to be imported from module SYSTEM (!), e.g.,
y := VAL(T,x).  Finally, NEW and DISPOSE are not supported, so you have
to call Allocate and Deallocate -- imported from module System (!!) -- instead.
This system was announced on the net about a month or so ago.

I have used both systems a little.  The 5-pass compiler is fairly slow.
Moreover, you have to go through an additional linking step.  However, the
quality of the generated code is fairly good.

I am truly amazed at the speed of the 1-pass compiler!  Moreover, since the
editor, compiler and debugger remain in main memory once they have been
started up, so the edit-compile-debug cycle is very fast indeed!
-- 

Robert Marti, Sun Microsystems, Inc.

UUCP: ...{cbosgd,decvax,decwrl,hplabs,ihnp4,pyramid,seismo,ucbvax}!sun!rmarti
ARPA: rmarti@sun.com