Some months back, when we were discussing which GOTOs could be considered
"harmless" in block-structured languages, I mentioned a paper which I had
written in 1977 for SIGPLAN Notices, and I promised to put its text up on my
website; but sadly I had lost access to the machine where my website was restored.

I have now reconstructed my website on a different machine, so you can now find
that paper if you look at http://www.clerew.man.ac.uk.

--
Charles H. Lindsey ---------At my New Home, still doing my own thing-----------
Tel: +44 161 488 1845 Web: http://www.cs.man.ac.uk/~chl
Email: chl@clerew.man.ac.uk Snail: 40 SK8 5BF, U.K.
PGP: 2C15F1A9 Fingerprint: 73 6D C2 51 93 A0 01 E7 65 E8 64 7E 14 A4 AB A5

On 06/05/2021 12:29, Charles Lindsey wrote:
> Some months back, when we were discussing which GOTOs could be
> considered "harmless" in block-structured languages, I mentioned a paper
> which I had written in 1977 for SIGPLAN Notices, and I promised to put
> its text up on my website; but sadly I had lost access to the machine
> where my website was restored.
>
> I have now reconstructed my website on a different machine, so you can
> now find that paper if you look at http://www.clerew.man.ac.uk.

Thanks, Charles. Good points about where to place labels to avoid
spaghetti code - especially for 1977!

What you say about 'completers' seems to match what I was suggesting in
our earlier discussion except, perhaps, that I was suggesting that exits
or 'completions' could be /via/ fragments of code.

I know your comments were about avoiding spaghetti code but what do you
see now as the overall merits or demerits of what you called 'repeaters'
compared with using an outer loop to effect the repetition?

I should say I couldn't quite match up the Algol on p47 with the
flowchart on p44 but Algol seems to me a strange beast!

--
James Harris

On 07/05/2021 09:23, James Harris wrote:
> On 06/05/2021 12:29, Charles Lindsey wrote:
>> Some months back, when we were discussing which GOTOs could be
>> considered "harmless" in block-structured languages, I mentioned a
>> paper which I had written in 1977 for SIGPLAN Notices, and I promised
>> to put its text up on my website; but sadly I had lost access to the
>> machine where my website was restored.
>>
>> I have now reconstructed my website on a different machine, so you can
>> now find that paper if you look at http://www.clerew.man.ac.uk.
>
> Thanks, Charles. Good points about where to place labels to avoid
> spaghetti code - especially for 1977!
>
> What you say about 'completers' seems to match what I was suggesting in
> our earlier discussion except, perhaps, that I was suggesting that exits
> or 'completions' could be /via/ fragments of code.
>
> I know your comments were about avoiding spaghetti code but what do you
> see now as the overall merits or demerits of what you called 'repeaters'
> compared with using an outer loop to effect the repetition?
>
> I should say I couldn't quite match up the Algol on p47 with the
> flowchart on p44 but Algol seems to me a strange beast!

Nothing to do with Algol, since you can write the same thing with C (see
below). Just an incredibly confusing bit of code.

while ( (ptr ? letter < ptr->letter : true)
? /*invent new node;*/ false
: letter > ptr->letter) {
ptr = ptr->bother;
}

The 'invent new mode' part is a comment with the Algol code, but is an
actual box in the flowchart. The 'false' outcome (not shown in the
flowchart) means the loop imediately exits.

If I had to code this logic, I think it's too complex to do with
expressions:

do
if ptr=nil then
# invent new node
exit
end

if letter<ptr.letter then
# invent new node
exit
elsif letter=ptr.letter then
exit
end

ptr := ptr.brother # letter > ptr.letter
end

Nope, it's still confusing. Back to the drawing board I think.

On 07/05/2021 11:58, Bart wrote:

....

> If I had to code this logic, I think it's too complex to do with
> expressions:
>
>     do
>         if ptr=nil then
>             # invent new node
>             exit
>         end
>
>         if letter<ptr.letter then
>             # invent new node
>             exit
>         elsif letter=ptr.letter then
>             exit
>         end
>
>         ptr := ptr.brother   # letter > ptr.letter
>     end
>
> Nope, it's still confusing. Back to the drawing board I think.

I think the comparison may need to be against ptr.brother.letter but I'm
not sure. I have to say, though, you've done a great job in separating
out < and = which was confusing me.

If I start with your code my direct translation of it would be something
like

loop
if p eq null
action = NEW_NODE
end loop
if-end

if letter lt p*.letter
action = NEW_NODE
end loop
if-end

if letter eq p*.letter
action = 0
end loop
if-end

p = p*.brother ;letter gt p*.letter
loop-end

if action eq NEW_NODE
;Invent new node
if-end

However, it is an excellent example of where exit labels that I proposed
in the earlier discussion could be exploited. With exit labels it can become

loop

if p eq null so choose loop-newnode

if letter lt p*.letter so choose loop-newnode

if letter eq p*.letter so choose loop-end

p = p*.brother ;letter gt p*.letter

loop-newnode
;Invent new node

loop-end

--
James Harris

On 07/05/2021 09:23, James Harris wrote:

> Thanks, Charles. Good points about where to place labels to avoid spaghetti code
> - especially for 1977!
>
> What you say about 'completers' seems to match what I was suggesting in our
> earlier discussion except, perhaps, that I was suggesting that exits or
> 'completions' could be /via/ fragments of code.
>
> I know your comments were about avoiding spaghetti code but what do you see now
> as the overall merits or demerits of what you called 'repeaters' compared with
> using an outer loop to effect the repetition?

I think repeaters and completers are particularly useful when there are several
places in the loop where you might like to repeat or complete. But they also
offer the possibility (at least in my structure chart notation) of completing or
repeating a specific loop in some nested loop structure. Note also that they can
apply to any block, not just a loop.

But to achieve this, you have to be able to 'label' each block. In C, they apply
only to the innermost loop and you have to use jumps to get to the outer loops.
>
> I should say I couldn't quite match up the Algol on p47 with the flowchart on
> p44 but Algol seems to me a strange beast!

Yes, that notation in A68 works, but it is not obvious if you are unfamiliar
with it.

--
Charles H. Lindsey ---------At my New Home, still doing my own thing-----------
Tel: +44 161 488 1845 Web: http://www.cs.man.ac.uk/~chl
Email: chl@clerew.man.ac.uk Snail: 40 SK8 5BF, U.K.
PGP: 2C15F1A9 Fingerprint: 73 6D C2 51 93 A0 01 E7 65 E8 64 7E 14 A4 AB A5