From mboxrd@z Thu Jan  1 00:00:00 1970
X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me
X-Spam-Level: 
X-Spam-Status: No, score=-1.3 required=5.0 tests=BAYES_00,INVALID_MSGID
	autolearn=no autolearn_force=no version=3.4.4
X-Google-Language: ENGLISH,ASCII-7-bit
X-Google-Thread: 103376,8f8cea8602e61aba
X-Google-Attributes: gid103376,public
From: dewar@merv.cs.nyu.edu (Robert Dewar)
Subject: Re: The Red Language
Date: 1997/09/21
Message-ID: <dewar.874850594@merv>#1/1
X-Deja-AN: 274315370
References: <340E2DC5.25D7@worldnet.att.net>
 <Pine.SGI.3.95.970916190053.19184D-100000@shellx.best.com>
 <EGoLLn.ABt@world.std.com> <dewar.874664808@merv> <EGrv5y.C2D@world.std.com>
Organization: New York University
Newsgroups: comp.lang.ada
Date: 1997-09-21T00:00:00+00:00
List-Id: <comp.lang.ada>


<<Well, I suppose in the bad old days, a "pass" in a compiler had
  something to do with reading a representation of the source program from
  the disk, and writing back a different representation.  I agree this is
  not a useful way to look at it.  (I recall using a Pascal compiler that
  required me to remove the "pass 1" floppy, and insert the "pass 2"
  floppy, for each compile.)>>

I think this is still the inspiration for whatever meaning a "pass" has
in compilers today, i.e. a full traversal of some representation of the
program.

The rub is "full", just how full must a traversal be to be considered
a pass. For example, in GNAT, there is a circuit at the end of the
parser to fill in declarations for labels. Is this a pass? I would
say no, but it is open to argument. As soon as you have random access
to the representation, the definition is no longer clear (and is
incidentally, not particularly useful -- in the old days there was
far more connection between the notions of efficiency in compilation
time and number of passes than there is today).

<<Could you briefly explain the Algol 68 rule?  Better yet, tell me where
  I can get my hands on the manual!  I've read stuff *about* Algol 68, but
  I want to read the actual language definition (which, I understand, is
  rather tough going).>>

Algol-68 overloading is strictly based on operand types. There are two
sources for looking at A68. First there was an article in Computing
Surveys (one of its early issues), I *think* the title was something
like "Algol-68 without Tears", but I could be imagining.

A more comprehensive reference is Charles Lindsay's informal introduction
(Charles is a sometime reader of CLA, maybe he will notice this reference
and tell us the current availability of this book). Note that this is
informal only by comparison to the formal definition, it is in fact a
thorough and precise description of the entire language that is very
readable.

Finally, one more reference for just learning Algol-68 in a hurry is
Ian Currie's magnificent 70-page "yellow book" that came with Algol-68R.
This is a masterpiece of covering a lot of critical technical material,
at an easily readable level, in a remarkably short space. A corresponding
Ada 95 text would be most welcome.

Ian's book was the key for me in getting "into" Algol-68. I had given up
on the Revised Report (though later I joined the very select club of those
who really new the RR very well, and appreciated it's precision and style).