Re: ALTER, ASSIGN and labels-as-values

EricP wrote:

MitchAlsup1 wrote:

Anton Ertl wrote:
 

EricP <ThatWouldBeTelling@thevillage.com> writes:

Don't forget Fortran's alternate returns, indicated by a * in the arg
list.
A caller subroutine passes *labels in the args list, and callee decides
which *label-arg it wants to return to in the RETURN statement constant
expression. (This is not ambiguous because in Fortran function return
values are done by assignment to the function name, not the return
statement expression.)
>
call Foo (*100, *200)
...
100
...
200
...
end
>
subroutine Foo (*, *)
...
return 1       ! Return to callers first * label arg
...
return 2       ! Return to callers second * label arg
...
end

 

Interesting.  Rudimentary explicit continuation-passing style at the
dawn of programming languages.  Of course, these days it would mean
that you better not use the common call and return instructions,
because the branch prediction for the return would be wrong if return
1 or return 2 would be used.  But using plain jump for the call and
indirect jumps for the returns should be efficient on modern CPUs.

 That is why the subroutine returns a value and the return point implements the switch (control transfer to proper label.
 {You DO NOT return to the label, you return normally and then go to the
 proper label.}

You still could do it by callee loading the arg address to register
and jumping directly there.

If it uses callee stack cleanup then you load the reg and pop the
stack before jumping.

If it uses caller stack cleanup then since caller controls what jump
addresses are passed to the callee, caller follows labels 100 and 200
each with stack cleanup code then continues normally.

If it doesn't use a stack at all, as I understand IBM Fortran did,
then it doesn't need cleanup.

IBM FORTRAN used a list of register store areas--thus pretty much like
a stack, just without the ability to be reentrant or recursive.