Re: stopping a loop iteration without exiting it

[Robert Eachus <rieachus@comcast.net>]

I probably shouldn't wake up this topic, and that is not my intent.  Just to bring up some history.  When the original ANSI standarization was going on, Pat Prange and I were supporting/maintaining a program called LALR on Multics. LALR would generate LALR(k)--look ahead left-to-right with k symbol lookahead--grammars.  It would generate a (very compact) set of tables, and (from source with embedded CFG (context free grammar) productions which defined the LALR(k) grammar.  We used it for a compiler that started out as GREEN, and evolved into a subset of Ada. (No tasking, and restrictions on generics.)

Robert Dewar preferred LL(1) grammars for Ada compilers since they allowed for better syntax error recovery.   LALR had a neat recovery method which required some fairly tiny tables (less than a hundred 32 or 36 bit words long).  The tables were generated along with the rest of the grammar tables, and were used for several Multics compilers, including the PL/I compiler and MRDS the Multics relational database. Anyway...

If you are going to use a program that needs to generate code containing and using finite state machine (FSM)* tables, you need to have gotos.  So they are necessary in Ada. Neither Robert Dewar or I ever found a use other than implementing FSMs and PDAs that required gotos--all the logic constructs argued above, whether simple or complex, can be turned into FSMs and implemented by a FSM tool.  Not that I recommend it for the simple cases.  For a lexical scanner?  Your choice. For complex flight control software?  The time spent by the avionics designers working over those tables will make the coding effort seem trivial.

* Technically, a parser generator tool generates a pushdown automaton PDA).  This is an FSM with a stack, and certain inputs cause pushing the current state on the stack, or processing the current CFG production then popping the stack. Pushdown automata can recognize any deterministic language with a context free grammar, but most tools are restricted to produce smaller and faster compilers.  (Doesn't cause any grief for language designers.  As long as the language is deterministic (not ambiguous) you can choose your tool.  Early's Algorithm will parse any CFG, but it sometimes takes time O(n^3) where n is the length of the input.  Most good grammars result in parsers which run in O(n log2 n) time or some such.  LL(1) grammars are also known as recursive descent grammars.  Most compiler programmers don't think about what they are writing as a PDA.

Oh, and regular expressions (RE), which are often used to describe the lexical symbols can be parsed without a stack--and again specialized tools make things much faster.