1) Is r.P^ the only legal notation for the call of the procedure P bound
   to the base type of r (in the following named 'super call ')?

I would say no, because r (as a receiver) can be of a pointer type, so
that r^.P^ should also be legal (knowing that r^.x can be abbreviated by
r.x). This raises the (not too serious) question:

2) Are 'complex' designators (e.g. r.a.b[e].P^) legal for a super call?

I tend to say no. If one says yes to 2), then the restriction of r to be a
receiver parameter would be too strong and super calls for any (record
typed) variables/parameters should be legal.

3) What are the main reasons for this restriction and why not cut this?

Another point in this issue is the sentence "Within a redefining
procedure the redefined procedure can be invoked by calling it with the
suffix ^ ..." found in Differences between Oberon and Oberon-2, which
seems a bit more restrictive than the relevant statements in the language
report:

4) If the only legal super call is a call of the redefined procedure
   within the redefining procedure, why it doesn't stand in this clarity
   in the language report?

Any opinions?

Max Spring

TYPE    P0 = POINTER TO T0  ;
        T0 = RECORD ... END ;

PROCEDURE (p:P0) Proc (params) ;
BEGIN ... END Proc;

TYPE    P1 = POINTER TO T1 ;
        T1 = RECORD (T0) ... END ;

PROCEDURE (p1 : P1) Proc (params) ;
BEGIN ....  
      p1^.Proc^(params)
END Proc ;

The super-call clearly isn't legal, because it is a call to a procedure
bound to the base type of the dereference of p1, which is of type T0,
not P0;

It has to be said, however, that I haven't run across a time when I
actually needed this to be the case.

--
-------------------------------------------------------------------------
Ian Marshall,
Real Time Associates Ltd,          Tel        : (+44)(0)81 656 7333/4/5
Canning House, 59 Canning Road,    Fax        : (+44)(0)81 655 0401

UK                                 Compuserve : 71333,2456      
-------------------------------------------------------------------------

:>1) Is r.P^ the only legal notation for the call of the procedure P bound
:>   to the base type of r (in the following named 'super call ')?
:>
:>I would say no, because r (as a receiver) can be of a pointer type, so
:>that r^.P^ should also be legal (knowing that r^.x can be abbreviated by
:>r.x). This raises the (not too serious) question:
:This cannot be correct, as can be seen if you look at the semantics of the
:call. If you have definitions as follows,
:TYPE    P0 = POINTER TO T0  ;
:        T0 = RECORD ... END ;
:PROCEDURE (p:P0) Proc (params) ;
:BEGIN ... END Proc;
:TYPE    P1 = POINTER TO T1 ;
:        T1 = RECORD (T0) ... END ;
:PROCEDURE (p1 : P1) Proc (params) ;
:BEGIN ....
:      p1^.Proc^(params)
:END Proc ;
:The super-call clearly isn't legal, because it is a call to a procedure
:bound to the base type of the dereference of p1, which is of type T0,
:not P0;

I'm afraid this is not correct!
Procecures are never bound to pointer types: The Oberon-2 Language Report
states in 10.2 Type-bound procedures: "Globally declared procedures may be
associated with a _record_ type declared in the same module. The
procedures are said to be bound to the _record_ type. ... The receiver may
be ... a value parameter of type POINTER TO T (where T is a _record_
type). The procedure is bound to the type _T_ ..."
And so the super-call IS legal.

:>
:>2) Are 'complex' designators (e.g. r.a.b[e].P^) legal for a super call?
:
:Only if the last element of the designator list (in your case b[e]) is of
:the same type as the receiver of the procedure it is called from.

From what passages of the language report do you infer that?

Max Spring.