The Free On-line Dictionary of Computing (19 January 2023):

COME FROM

    A semi-mythical language construct dual
   to the "go to"; "COME FROM"  would cause the referenced
   label to act as a sort of trapdoor, so that if the program
   ever reached it, control would quietly and automagically be
   transferred to the statement following the "COME FROM".

   "COME FROM" was first proposed in R.L. Clark's "A Linguistic
   Contribution to GOTO-less programming", which appeared in a
   1973 Datamation issue (and was reprinted in the April 1984
   issue of "Communications of the ACM").  This parodied the
   then-raging "structured programming" holy wars (see
   considered harmful).

   Mythically, some variants are the "assigned COME FROM" and the
   "computed COME FROM" (parodying some nasty control constructs
   in Fortran and some extended BASICs).  Of course,
   multitasking (or nondeterminism) could be implemented by
   having more than one "COME FROM" statement coming from the
   same label.

   In some ways the Fortran "DO" looks like a "COME FROM"
   statement.  After the terminating statement number/"CONTINUE"
   is reached, control continues at the statement following the
   DO.  Some generous Fortrans would allow arbitrary statements
   (other than "CONTINUE") for the statement, leading to examples
   like:

         DO 10 I=1,LIMIT
    C imagine many lines of code here, leaving the
    C original DO statement lost in the spaghetti...
         WRITE(6,10) I,FROB(I)
    10   FORMAT(1X,I5,G10.4)

   in which the trapdoor is just after the statement labelled 10.
   (This is particularly surprising because the label doesn't
   appear to have anything to do with the flow of control at
   all!)

   While sufficiently astonishing to the unsuspecting reader,
   this form of "COME FROM" statement isn't completely general.
   After all, control will eventually pass to the following
   statement.  The implementation of the general form was left to
   Univac Fortran, ca. 1975 (though a roughly similar feature
   existed on the IBM 7040 ten years earlier).  The statement
   "AT 100" would perform a "COME FROM 100".  It was intended
   strictly as a debugging aid, with dire consequences promised
   to anyone so deranged as to use it in production code.  More
   horrible things had already been perpetrated in production
   languages, however; doubters need only contemplate the
   "ALTER" verb in COBOL.

   SCL on VME mainframes has a similar language construct
   called "whenever", used like this:

     whenever x=123345 then S;

   Meaning whenever variable x reached the value 123345 then
   execute statement S.

   "COME FROM" was supported under its own name for the first
   time 15 years later, in C-INTERCAL (see INTERCAL,
   retrocomputing); knowledgeable observers are still reeling
   from the shock.

   [Jargon File]

   (1998-04-19)


The Jargon File (version 4.4.7, 29 Dec 2003):

COME FROM
 n.

    A semi-mythical language construct dual to the ‘go to’; COME FROM 
    would cause the referenced label to act as a sort of trapdoor, so that if
    the program ever reached it control would quietly and automagically be
    transferred to the statement following the COME FROM. COME FROM was first
    proposed in R. Lawrence Clark's A Linguistic Contribution to GOTO-less
    programming, which appeared in a 1973 Datamation issue (and was reprinted
    in the April 1984 issue of Communications of the ACM). This parodied the
    then-raging ‘structured programming’ holy wars (see considered harmful
    ). Mythically, some variants are the assigned COME FROM and the computed
    COME FROM (parodying some nasty control constructs in FORTRAN and some
    extended BASICs). Of course, multi-tasking (or non-determinism) could be
    implemented by having more than one COME FROM statement coming from the
    same label.

    In some ways the FORTRAN DO looks like a COME FROM statement. After the
    terminating statement number/CONTINUE is reached, control continues at the
    statement following the DO. Some generous FORTRANs would allow arbitrary
    statements (other than CONTINUE) for the statement, leading to examples
    like:

          DO 10 I=1,LIMIT
    C imagine many lines of code here, leaving the
    C original DO statement lost in the spaghetti...
          WRITE(6,10) I,FROB(I)
     10   FORMAT(1X,I5,G10.4)

    in which the trapdoor is just after the statement labeled 10. (This is
    particularly surprising because the label doesn't appear to have anything
    to do with the flow of control at all!) While sufficiently astonishing to
    the unsuspecting reader, this form of COME FROM statement isn't completely
    general. After all, control will eventually pass to the following
    statement. The implementation of the general form was left to Univac
    FORTRAN, ca. 1975 (though a roughly similar feature existed on the IBM 7040
    ten years earlier). The statement AT 100 would perform a COME FROM 100. It
    was intended strictly as a debugging aid, with dire consequences promised
    to anyone so deranged as to use it in production code. More horrible things
    had already been perpetrated in production languages, however; doubters
    need only contemplate the ALTER verb in COBOL. COME FROM was supported
    under its own name for the first time 15 years later, in C-INTERCAL (see 
    INTERCAL, retrocomputing); knowledgeable observers are still reeling
    from the shock.