When were the analogs of the C operators "break" and "continue" introduced in Pascal?

Question

When published in 1970, the Pascal language did not have a way to implement the functionality equivalent to the (future) C language operators "break" and "continue". Their convenience having been recognized, extended dialects of Pascal have started to feature similar operators.

From the same documentation for an implementation of Pascal for a Soviet computer as here, dated 1979:

In accordance with the ideas of structural programming and the requirements of programming practice, the following control structures are introduced in the language:

Structural labels

An operator can be labeled with a structural label.

<operator> ::= { <label>: }* { ( <structural label> ) }* <unlabeled operator>

<structural label> ::= <identifier>

The scope of a structural label is the unlabeled operator.

exit operator

Within the scope of a structural label, e. g. "(M)", there may be operators exit M, equivalent to exiting the corresponding unlabeled operator.

Syntax

<exit operator> ::= exit <structural label>

goto operator

Syntax

<goto operator> ::= goto ( <label> | <structural label> )

A goto operator using a structural label may appear within the scope of that structural label. Its function is equivalent to the regular goto operator.

Structural labels realize the right of each operator to iterate and to complete.

(Most readers of the documentation would later misquote the last statement as "the inalienable right of each operator to iterate and to complete".)

TL;DR: Structural labels implement mechanisms akin to generalized "break" and "continue" operators on the C language. For example:

(outerloop) for i := 1 to 100 do
(innerloop) for j := 1 to 100 do
     (iter) begin
            ...
            exit iter; { same as continue in C }
            ...
            exit innerloop; { same as break in C }
            ...
            exit outerloop; { no convenient C analog }
     end

Unlike regular numerical labels in Pascal, structural labels did not need to be pre-declared.

Turbo Pascal appeared in the 1980s and seems to have regular C-like break and continue.

---

The question is: Has any pre-1979 dialect of Pascal featured "structural labels", or any kind of break/continue functionality?

Answer 1

It is difficult to say for sure, because there have been a lot of implementations of the Pascal Language (some of them not very widely distributed), each with their own specific additions to the language.

Anyway, my researchs show that it is very unlikely that a feature like the one you describe have been made available before 1979:

• The Turbo Pascal compiler (which has certainly been one of the most widely ditributed Pascal implementations, and stands, at least for me, as a reference) has, indeed, introduced break/continue statements, but not before the 7.0 version, released in 1992. See the reference manuals available here. In a paragraph named "Flow control procedures", you'll see the break/continue statements are mentioned for the 7.0 version, but not for the 6.0 version.
• The Pascal MT+, released in 1980, show no such thing in its reference manual (available here).
• The UCSD Pascal, released in 1978, is simply based on the Wirth definition of Pascal with a few additions, but nothing that looks like a break/continue statement (manual here).

I made some additional researchs on other implementations, but almost all of them are said to be close to the ISO 7185 standard, and I couldn't find the manuals online.

Anyway, the fact that Borland introduced this feature so late (and that nobody answered this question yet) should be convincing enough. I may have missed some very obscure implementations, though (like the one you mention).

Answer 2

From the beginning Pascal has always had a goto statement. So while it didn't have explicit break and continue, they were trivially easy to emulate:

while someCondition do
  begin
    2: 
    (* do some stuff *)
    goto 1; (* Equivalent to break *)
    (* do some more stuff *)
    goto 2;
    (* do even more stuff *)
  end;
1:

break and continue are more convenient of course but they are essentially just goto statements and personally I really don't like them. I've never used continue and I only use break in C switch statements.

Answer 3

Because break and continue are a form of goto. To see why lets review basic Pascal structures a bit (at least those that would be applicable to break and continue):

while x do y; repeat y until x; for i := s to e do;

Taking one of them:

while x do begin

  s1;
  s2;
  s3;

end;

Using C breaks you could break anywhere in that sequence:

while x do begin

  break;
  s1;
  break;
  s2;
  break;
  s3;
  break;

end;

You can substitute "continue" for "break" anywhere in the above.

All Pascal structured statements have the characteristics that:

1. They have a single point of control entry.
2. They have a single point of control exit.

Thus with break and continue you change "single point of exit" to (basically) anywhere. Its only limitation is that it must be contained within the loop.

Structured programming is based on the idea that with a few simple single entry/single exit constructs you can write any program. It sometimes is not easy, which is why break and continue exist in C and other languages.

So the above example is trivial, but imagine going through a loop that spans a page or more. It can be a challenge to find what is or is not executed within the loop.

Similarly, compilers can also have difficulty unwinding the different paths through the code, and what the compiler can not easily determine means that it cannot also readily optimize for it.