Terje said:
Not at all:
Did you ever _use_ the Logitech Modula II compiler?
Yes, and for some moderately large projects. It was a reliable
industrial strength compiler for the x86 from about version 2.01 onwards
(c/a 1985). 2.10 was particularly good and stable. I do recall some
serious fun when they suddenly changed the default byte alignment in
structures in one release (which was not a very friendly thing to do).
ISTR it was a slow 4-pass compiler and it's code generator was more than
a bit pedestrian even for the time (but you could add inline code). The
overlay linker was incredibly good, and the debugging facilities were
first rate - comparable with the mainframe tools they copied. Parts of
DEC were actually using the language internally at the time. In the
event of a rare system failure you could be almost certain of finding
the root cause from the PMD in the symbolic debugger.
I did, and it was the most broken piece of programming I've had the
misfortune to work with: Among _many_ other things, the compiler would
generate faulty code for all loop constructs except one (WHILE afair).
To be totally fair, the compiler developers probably knew about most of
these bugs, and were only midway in the process of making the compiler
host itself: The version they sold me were called "V0.3c"! :-(
If you buy a pre-release version 0 bootstrapping prototype what do you
expect? I am surprised they sold you it in that state.
At this time Borland came out with Anders Heijlsberg's Turbo Pascal,
which ran rings around Logitech M2, in pretty much every possible way.
A spin off from the Borland compiler development group headed by Niels
Jensen produced by far the most appealing PC version of Modula2 as JPI.
It's libraries were non-standard, but at the time it's code generation
was state of the art and fast. They developed it independently and it
had some very good vintage versions 1.17 and 3.04 spring to mind.
They had a no-compete clause with Borland for C-compilers and when it
timed out they launched the most horribly buggy C-compiler I have ever
seen. It would crash spectacularly on minor syntax errors (missing ; and
that sort of thing). Code generation was OK if it worked. It did for
them and Clarion took them over (as they used the JPI M2 internally).
These days XDS has probably the most interesting Modula 2 compiler and
they now give it away. It's code generator includes powerful static
dataflow analysis to find path dependency bugs. It can find faults in
old legacy code and has libraries that mimic JPI and PIM3 dialects.
I'd have expected Modula 2 to appeal to electronics engineers because it
provides a means to make robust independent modules that can be trusted
to do exactly what they say on the tin.
Regards,
Martin Brown