Flow-control structures

In this task, we document common flow-control structures. One common example of a flow-control structure is the goto construct. Note that Conditional Structures and Loop Structures have their own articles.

Ada

goto

Top:
   Put_Line("Hello, World");
   goto Top;

exit

Exit is used to break out of loops. Exit can be used with a label to break out of an inner loop to an outer loop and its enclosing outer loop

Outer:
   loop
      -- do something
      loop
         -- do something else
         exit Outer; -- exits both the inner and outer loops
      end loop;
   end loop;

C++

goto

Compiler: GCC 3.3.4

#include <iostream> 

int main()
{
 LOOP:
  std::cout << "Hello, World!\n";
 goto LOOP;
}

Note that "goto" may also be used in conjunction with other forms of branching.

Exceptions

Compiler: GCC 4.0.2

Exceptions are a way to give control back to a direct or indirect caller in case of an error.

#include <iostream>
#include <ostream>

void foo()
{
  std::cout << "Going to throw an exception.\n";
  throw 7; // almost any object can be thrown, including ints
  std::throw << "This output will never execute.\n";
}

void bar()
{
  std::cout << "Going to call foo().\n";
  foo();
  std::cout << "This will be skipped by the exception coming from foo.\n";
}

void baz()
{
  try // everything thrown from inside the following code block
  {   // will be covered by the following catch clauses
    std::cout << "Going to call bar().\n";
    bar();
    std::cout << "This will be skipped by the exception coming from foo.\n";
  }
  catch(...) // a simple catch-all, but doesn't give access to the thrown exception
  {
    std::cout << "An exception occured. I'll just throw it on.\n";
    throw; // without an argument, the caught exception is re-thrown
  }
  std::cout << "This will not be executed due to the re-throw in the catch block\n";
}

void foobar()
{
  try
  {
    baz();
  }
  catch(char const* s)
  {
    std::cout << "If foo had thrown a char const*, this code would be executed.\n";
    std::cout << "In that case, the thrown char const* would read " << s << ".\n";
  }
  catch(int i)
  {
    std::cout << "Caught an int, with value " << i << " (should be 7).\n";
    std::cout << "Not rethrowing the int.\n";
  }
  catch(...)
  {
    std::cout << "This catch-all doesn't get invoked because the catch(int) above\n"
              << "already took care of the exception (even if it had rethrown the\n"
              << "exception, this catch-all would not be invoked, because it's\n"
              << "only invoked for exceptions coming from the try block.\n";
  }
  std::cout << "This will be executed, since the exception was handled above, and not rethrown.\n";
}

int main()
{
  try
  {
    foobar();
  }
  catch(...)
  {
    std::cout << "The main function never sees the exception, because it's completely handled\n"
              << "inside foobar(). Thus this catch-all block never gets invoked.\n";
  }
}

IDL

goto

 test:
 ..some code here
 goto, test

(This is almost never used)

on_error

 on_error, test

(This resumes at the label test if an error is encountered)

on_ioerror

 on_ioerror, test

(Same as on_error, but for EOFs and read-errors and such)

break

break

immediately terminates the innermost current loop (or if or case etc)

continue

continue

immediately starts the next iteration of the current innermost loop

Perl

Interpreter: Perl 5.x

goto

Goto is typically looked down upon by most perl programmers

FORK:
# some code
goto FORK;

Tcl

exception

Tcl's catch command can be used to provide a basic exception-handling mechanism:

 if {[catch { ... code that might give error ... } result]} {
   puts "Error was $result"
 } else {
   ... process $result ...
 }

custom control structures

A novel aspect of Tcl is that it's relatively easy to create new control structures (more detail at http://wiki.tcl.tk/685). Eg. defining a command to perform some operation for each line of an input file:

 proc forfilelines {linevar filename code} {
   upvar $linevar line	; # connect local variable line to caller's variable
   set filechan [open $filename]
   while {[gets $filechan line] != -1} {
     uplevel 1 $code	; # Run supplied code in caller's scope
   }
   close $filechan
 }

Now use it to print the length of each line of file "mydata.txt":

 forfilelines myline mydata.txt {
   puts [string length $myline]
 }